Line data Source code
1 : /*
2 : * Copyright (C) 2014 Red Hat
3 : * Copyright (C) 2014 Intel Corp.
4 : *
5 : * Permission is hereby granted, free of charge, to any person obtaining a
6 : * copy of this software and associated documentation files (the "Software"),
7 : * to deal in the Software without restriction, including without limitation
8 : * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 : * and/or sell copies of the Software, and to permit persons to whom the
10 : * Software is furnished to do so, subject to the following conditions:
11 : *
12 : * The above copyright notice and this permission notice shall be included in
13 : * all copies or substantial portions of the Software.
14 : *
15 : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 : * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 : * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 : * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 : * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 : * OTHER DEALINGS IN THE SOFTWARE.
22 : *
23 : * Authors:
24 : * Rob Clark <robdclark@gmail.com>
25 : * Daniel Vetter <daniel.vetter@ffwll.ch>
26 : */
27 :
28 : #include <linux/dma-fence.h>
29 : #include <linux/ktime.h>
30 :
31 : #include <drm/drm_atomic.h>
32 : #include <drm/drm_atomic_helper.h>
33 : #include <drm/drm_atomic_uapi.h>
34 : #include <drm/drm_blend.h>
35 : #include <drm/drm_bridge.h>
36 : #include <drm/drm_damage_helper.h>
37 : #include <drm/drm_device.h>
38 : #include <drm/drm_drv.h>
39 : #include <drm/drm_framebuffer.h>
40 : #include <drm/drm_gem_atomic_helper.h>
41 : #include <drm/drm_print.h>
42 : #include <drm/drm_self_refresh_helper.h>
43 : #include <drm/drm_vblank.h>
44 : #include <drm/drm_writeback.h>
45 :
46 : #include "drm_crtc_helper_internal.h"
47 : #include "drm_crtc_internal.h"
48 :
49 : /**
50 : * DOC: overview
51 : *
52 : * This helper library provides implementations of check and commit functions on
53 : * top of the CRTC modeset helper callbacks and the plane helper callbacks. It
54 : * also provides convenience implementations for the atomic state handling
55 : * callbacks for drivers which don't need to subclass the drm core structures to
56 : * add their own additional internal state.
57 : *
58 : * This library also provides default implementations for the check callback in
59 : * drm_atomic_helper_check() and for the commit callback with
60 : * drm_atomic_helper_commit(). But the individual stages and callbacks are
61 : * exposed to allow drivers to mix and match and e.g. use the plane helpers only
62 : * together with a driver private modeset implementation.
63 : *
64 : * This library also provides implementations for all the legacy driver
65 : * interfaces on top of the atomic interface. See drm_atomic_helper_set_config(),
66 : * drm_atomic_helper_disable_plane(), and the various functions to implement
67 : * set_property callbacks. New drivers must not implement these functions
68 : * themselves but must use the provided helpers.
69 : *
70 : * The atomic helper uses the same function table structures as all other
71 : * modesetting helpers. See the documentation for &struct drm_crtc_helper_funcs,
72 : * struct &drm_encoder_helper_funcs and &struct drm_connector_helper_funcs. It
73 : * also shares the &struct drm_plane_helper_funcs function table with the plane
74 : * helpers.
75 : */
76 : static void
77 0 : drm_atomic_helper_plane_changed(struct drm_atomic_state *state,
78 : struct drm_plane_state *old_plane_state,
79 : struct drm_plane_state *plane_state,
80 : struct drm_plane *plane)
81 : {
82 : struct drm_crtc_state *crtc_state;
83 :
84 0 : if (old_plane_state->crtc) {
85 0 : crtc_state = drm_atomic_get_new_crtc_state(state,
86 : old_plane_state->crtc);
87 :
88 0 : if (WARN_ON(!crtc_state))
89 : return;
90 :
91 0 : crtc_state->planes_changed = true;
92 : }
93 :
94 0 : if (plane_state->crtc) {
95 0 : crtc_state = drm_atomic_get_new_crtc_state(state, plane_state->crtc);
96 :
97 0 : if (WARN_ON(!crtc_state))
98 : return;
99 :
100 0 : crtc_state->planes_changed = true;
101 : }
102 : }
103 :
104 0 : static int handle_conflicting_encoders(struct drm_atomic_state *state,
105 : bool disable_conflicting_encoders)
106 : {
107 : struct drm_connector_state *new_conn_state;
108 : struct drm_connector *connector;
109 : struct drm_connector_list_iter conn_iter;
110 : struct drm_encoder *encoder;
111 0 : unsigned int encoder_mask = 0;
112 0 : int i, ret = 0;
113 :
114 : /*
115 : * First loop, find all newly assigned encoders from the connectors
116 : * part of the state. If the same encoder is assigned to multiple
117 : * connectors bail out.
118 : */
119 0 : for_each_new_connector_in_state(state, connector, new_conn_state, i) {
120 0 : const struct drm_connector_helper_funcs *funcs = connector->helper_private;
121 : struct drm_encoder *new_encoder;
122 :
123 0 : if (!new_conn_state->crtc)
124 0 : continue;
125 :
126 0 : if (funcs->atomic_best_encoder)
127 0 : new_encoder = funcs->atomic_best_encoder(connector,
128 : state);
129 0 : else if (funcs->best_encoder)
130 0 : new_encoder = funcs->best_encoder(connector);
131 : else
132 0 : new_encoder = drm_connector_get_single_encoder(connector);
133 :
134 0 : if (new_encoder) {
135 0 : if (encoder_mask & drm_encoder_mask(new_encoder)) {
136 0 : drm_dbg_atomic(connector->dev,
137 : "[ENCODER:%d:%s] on [CONNECTOR:%d:%s] already assigned\n",
138 : new_encoder->base.id, new_encoder->name,
139 : connector->base.id, connector->name);
140 :
141 0 : return -EINVAL;
142 : }
143 :
144 0 : encoder_mask |= drm_encoder_mask(new_encoder);
145 : }
146 : }
147 :
148 0 : if (!encoder_mask)
149 : return 0;
150 :
151 : /*
152 : * Second loop, iterate over all connectors not part of the state.
153 : *
154 : * If a conflicting encoder is found and disable_conflicting_encoders
155 : * is not set, an error is returned. Userspace can provide a solution
156 : * through the atomic ioctl.
157 : *
158 : * If the flag is set conflicting connectors are removed from the CRTC
159 : * and the CRTC is disabled if no encoder is left. This preserves
160 : * compatibility with the legacy set_config behavior.
161 : */
162 0 : drm_connector_list_iter_begin(state->dev, &conn_iter);
163 0 : drm_for_each_connector_iter(connector, &conn_iter) {
164 : struct drm_crtc_state *crtc_state;
165 :
166 0 : if (drm_atomic_get_new_connector_state(state, connector))
167 0 : continue;
168 :
169 0 : encoder = connector->state->best_encoder;
170 0 : if (!encoder || !(encoder_mask & drm_encoder_mask(encoder)))
171 0 : continue;
172 :
173 0 : if (!disable_conflicting_encoders) {
174 0 : drm_dbg_atomic(connector->dev,
175 : "[ENCODER:%d:%s] in use on [CRTC:%d:%s] by [CONNECTOR:%d:%s]\n",
176 : encoder->base.id, encoder->name,
177 : connector->state->crtc->base.id,
178 : connector->state->crtc->name,
179 : connector->base.id, connector->name);
180 0 : ret = -EINVAL;
181 0 : goto out;
182 : }
183 :
184 0 : new_conn_state = drm_atomic_get_connector_state(state, connector);
185 0 : if (IS_ERR(new_conn_state)) {
186 0 : ret = PTR_ERR(new_conn_state);
187 0 : goto out;
188 : }
189 :
190 0 : drm_dbg_atomic(connector->dev,
191 : "[ENCODER:%d:%s] in use on [CRTC:%d:%s], disabling [CONNECTOR:%d:%s]\n",
192 : encoder->base.id, encoder->name,
193 : new_conn_state->crtc->base.id, new_conn_state->crtc->name,
194 : connector->base.id, connector->name);
195 :
196 0 : crtc_state = drm_atomic_get_new_crtc_state(state, new_conn_state->crtc);
197 :
198 0 : ret = drm_atomic_set_crtc_for_connector(new_conn_state, NULL);
199 0 : if (ret)
200 : goto out;
201 :
202 0 : if (!crtc_state->connector_mask) {
203 0 : ret = drm_atomic_set_mode_prop_for_crtc(crtc_state,
204 : NULL);
205 0 : if (ret < 0)
206 : goto out;
207 :
208 0 : crtc_state->active = false;
209 : }
210 : }
211 : out:
212 0 : drm_connector_list_iter_end(&conn_iter);
213 :
214 0 : return ret;
215 : }
216 :
217 : static void
218 0 : set_best_encoder(struct drm_atomic_state *state,
219 : struct drm_connector_state *conn_state,
220 : struct drm_encoder *encoder)
221 : {
222 : struct drm_crtc_state *crtc_state;
223 : struct drm_crtc *crtc;
224 :
225 0 : if (conn_state->best_encoder) {
226 : /* Unset the encoder_mask in the old crtc state. */
227 0 : crtc = conn_state->connector->state->crtc;
228 :
229 : /* A NULL crtc is an error here because we should have
230 : * duplicated a NULL best_encoder when crtc was NULL.
231 : * As an exception restoring duplicated atomic state
232 : * during resume is allowed, so don't warn when
233 : * best_encoder is equal to encoder we intend to set.
234 : */
235 0 : WARN_ON(!crtc && encoder != conn_state->best_encoder);
236 0 : if (crtc) {
237 0 : crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
238 :
239 0 : crtc_state->encoder_mask &=
240 0 : ~drm_encoder_mask(conn_state->best_encoder);
241 : }
242 : }
243 :
244 0 : if (encoder) {
245 0 : crtc = conn_state->crtc;
246 0 : WARN_ON(!crtc);
247 0 : if (crtc) {
248 0 : crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
249 :
250 0 : crtc_state->encoder_mask |=
251 0 : drm_encoder_mask(encoder);
252 : }
253 : }
254 :
255 0 : conn_state->best_encoder = encoder;
256 0 : }
257 :
258 : static void
259 0 : steal_encoder(struct drm_atomic_state *state,
260 : struct drm_encoder *encoder)
261 : {
262 : struct drm_crtc_state *crtc_state;
263 : struct drm_connector *connector;
264 : struct drm_connector_state *old_connector_state, *new_connector_state;
265 : int i;
266 :
267 0 : for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i) {
268 : struct drm_crtc *encoder_crtc;
269 :
270 0 : if (new_connector_state->best_encoder != encoder)
271 0 : continue;
272 :
273 0 : encoder_crtc = old_connector_state->crtc;
274 :
275 0 : drm_dbg_atomic(encoder->dev,
276 : "[ENCODER:%d:%s] in use on [CRTC:%d:%s], stealing it\n",
277 : encoder->base.id, encoder->name,
278 : encoder_crtc->base.id, encoder_crtc->name);
279 :
280 0 : set_best_encoder(state, new_connector_state, NULL);
281 :
282 0 : crtc_state = drm_atomic_get_new_crtc_state(state, encoder_crtc);
283 0 : crtc_state->connectors_changed = true;
284 :
285 0 : return;
286 : }
287 : }
288 :
289 : static int
290 0 : update_connector_routing(struct drm_atomic_state *state,
291 : struct drm_connector *connector,
292 : struct drm_connector_state *old_connector_state,
293 : struct drm_connector_state *new_connector_state)
294 : {
295 : const struct drm_connector_helper_funcs *funcs;
296 : struct drm_encoder *new_encoder;
297 : struct drm_crtc_state *crtc_state;
298 :
299 0 : drm_dbg_atomic(connector->dev, "Updating routing for [CONNECTOR:%d:%s]\n",
300 : connector->base.id, connector->name);
301 :
302 0 : if (old_connector_state->crtc != new_connector_state->crtc) {
303 0 : if (old_connector_state->crtc) {
304 0 : crtc_state = drm_atomic_get_new_crtc_state(state, old_connector_state->crtc);
305 0 : crtc_state->connectors_changed = true;
306 : }
307 :
308 0 : if (new_connector_state->crtc) {
309 0 : crtc_state = drm_atomic_get_new_crtc_state(state, new_connector_state->crtc);
310 0 : crtc_state->connectors_changed = true;
311 : }
312 : }
313 :
314 0 : if (!new_connector_state->crtc) {
315 0 : drm_dbg_atomic(connector->dev, "Disabling [CONNECTOR:%d:%s]\n",
316 : connector->base.id, connector->name);
317 :
318 0 : set_best_encoder(state, new_connector_state, NULL);
319 :
320 : return 0;
321 : }
322 :
323 0 : crtc_state = drm_atomic_get_new_crtc_state(state,
324 : new_connector_state->crtc);
325 : /*
326 : * For compatibility with legacy users, we want to make sure that
327 : * we allow DPMS On->Off modesets on unregistered connectors. Modesets
328 : * which would result in anything else must be considered invalid, to
329 : * avoid turning on new displays on dead connectors.
330 : *
331 : * Since the connector can be unregistered at any point during an
332 : * atomic check or commit, this is racy. But that's OK: all we care
333 : * about is ensuring that userspace can't do anything but shut off the
334 : * display on a connector that was destroyed after it's been notified,
335 : * not before.
336 : *
337 : * Additionally, we also want to ignore connector registration when
338 : * we're trying to restore an atomic state during system resume since
339 : * there's a chance the connector may have been destroyed during the
340 : * process, but it's better to ignore that then cause
341 : * drm_atomic_helper_resume() to fail.
342 : */
343 0 : if (!state->duplicated && drm_connector_is_unregistered(connector) &&
344 0 : crtc_state->active) {
345 0 : drm_dbg_atomic(connector->dev,
346 : "[CONNECTOR:%d:%s] is not registered\n",
347 : connector->base.id, connector->name);
348 : return -EINVAL;
349 : }
350 :
351 0 : funcs = connector->helper_private;
352 :
353 0 : if (funcs->atomic_best_encoder)
354 0 : new_encoder = funcs->atomic_best_encoder(connector, state);
355 0 : else if (funcs->best_encoder)
356 0 : new_encoder = funcs->best_encoder(connector);
357 : else
358 0 : new_encoder = drm_connector_get_single_encoder(connector);
359 :
360 0 : if (!new_encoder) {
361 0 : drm_dbg_atomic(connector->dev,
362 : "No suitable encoder found for [CONNECTOR:%d:%s]\n",
363 : connector->base.id, connector->name);
364 : return -EINVAL;
365 : }
366 :
367 0 : if (!drm_encoder_crtc_ok(new_encoder, new_connector_state->crtc)) {
368 0 : drm_dbg_atomic(connector->dev,
369 : "[ENCODER:%d:%s] incompatible with [CRTC:%d:%s]\n",
370 : new_encoder->base.id,
371 : new_encoder->name,
372 : new_connector_state->crtc->base.id,
373 : new_connector_state->crtc->name);
374 : return -EINVAL;
375 : }
376 :
377 0 : if (new_encoder == new_connector_state->best_encoder) {
378 0 : set_best_encoder(state, new_connector_state, new_encoder);
379 :
380 0 : drm_dbg_atomic(connector->dev,
381 : "[CONNECTOR:%d:%s] keeps [ENCODER:%d:%s], now on [CRTC:%d:%s]\n",
382 : connector->base.id,
383 : connector->name,
384 : new_encoder->base.id,
385 : new_encoder->name,
386 : new_connector_state->crtc->base.id,
387 : new_connector_state->crtc->name);
388 :
389 : return 0;
390 : }
391 :
392 0 : steal_encoder(state, new_encoder);
393 :
394 0 : set_best_encoder(state, new_connector_state, new_encoder);
395 :
396 0 : crtc_state->connectors_changed = true;
397 :
398 0 : drm_dbg_atomic(connector->dev,
399 : "[CONNECTOR:%d:%s] using [ENCODER:%d:%s] on [CRTC:%d:%s]\n",
400 : connector->base.id,
401 : connector->name,
402 : new_encoder->base.id,
403 : new_encoder->name,
404 : new_connector_state->crtc->base.id,
405 : new_connector_state->crtc->name);
406 :
407 : return 0;
408 : }
409 :
410 : static int
411 0 : mode_fixup(struct drm_atomic_state *state)
412 : {
413 : struct drm_crtc *crtc;
414 : struct drm_crtc_state *new_crtc_state;
415 : struct drm_connector *connector;
416 : struct drm_connector_state *new_conn_state;
417 : int i;
418 : int ret;
419 :
420 0 : for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
421 0 : if (!new_crtc_state->mode_changed &&
422 0 : !new_crtc_state->connectors_changed)
423 0 : continue;
424 :
425 0 : drm_mode_copy(&new_crtc_state->adjusted_mode, &new_crtc_state->mode);
426 : }
427 :
428 0 : for_each_new_connector_in_state(state, connector, new_conn_state, i) {
429 : const struct drm_encoder_helper_funcs *funcs;
430 : struct drm_encoder *encoder;
431 : struct drm_bridge *bridge;
432 :
433 0 : WARN_ON(!!new_conn_state->best_encoder != !!new_conn_state->crtc);
434 :
435 0 : if (!new_conn_state->crtc || !new_conn_state->best_encoder)
436 0 : continue;
437 :
438 0 : new_crtc_state =
439 : drm_atomic_get_new_crtc_state(state, new_conn_state->crtc);
440 :
441 : /*
442 : * Each encoder has at most one connector (since we always steal
443 : * it away), so we won't call ->mode_fixup twice.
444 : */
445 0 : encoder = new_conn_state->best_encoder;
446 0 : funcs = encoder->helper_private;
447 :
448 0 : bridge = drm_bridge_chain_get_first_bridge(encoder);
449 0 : ret = drm_atomic_bridge_chain_check(bridge,
450 : new_crtc_state,
451 : new_conn_state);
452 0 : if (ret) {
453 0 : drm_dbg_atomic(encoder->dev, "Bridge atomic check failed\n");
454 0 : return ret;
455 : }
456 :
457 0 : if (funcs && funcs->atomic_check) {
458 0 : ret = funcs->atomic_check(encoder, new_crtc_state,
459 : new_conn_state);
460 0 : if (ret) {
461 0 : drm_dbg_atomic(encoder->dev,
462 : "[ENCODER:%d:%s] check failed\n",
463 : encoder->base.id, encoder->name);
464 0 : return ret;
465 : }
466 0 : } else if (funcs && funcs->mode_fixup) {
467 0 : ret = funcs->mode_fixup(encoder, &new_crtc_state->mode,
468 : &new_crtc_state->adjusted_mode);
469 0 : if (!ret) {
470 0 : drm_dbg_atomic(encoder->dev,
471 : "[ENCODER:%d:%s] fixup failed\n",
472 : encoder->base.id, encoder->name);
473 0 : return -EINVAL;
474 : }
475 : }
476 : }
477 :
478 0 : for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
479 : const struct drm_crtc_helper_funcs *funcs;
480 :
481 0 : if (!new_crtc_state->enable)
482 0 : continue;
483 :
484 0 : if (!new_crtc_state->mode_changed &&
485 0 : !new_crtc_state->connectors_changed)
486 0 : continue;
487 :
488 0 : funcs = crtc->helper_private;
489 0 : if (!funcs || !funcs->mode_fixup)
490 0 : continue;
491 :
492 0 : ret = funcs->mode_fixup(crtc, &new_crtc_state->mode,
493 : &new_crtc_state->adjusted_mode);
494 0 : if (!ret) {
495 0 : drm_dbg_atomic(crtc->dev, "[CRTC:%d:%s] fixup failed\n",
496 : crtc->base.id, crtc->name);
497 0 : return -EINVAL;
498 : }
499 : }
500 :
501 : return 0;
502 : }
503 :
504 0 : static enum drm_mode_status mode_valid_path(struct drm_connector *connector,
505 : struct drm_encoder *encoder,
506 : struct drm_crtc *crtc,
507 : const struct drm_display_mode *mode)
508 : {
509 : struct drm_bridge *bridge;
510 : enum drm_mode_status ret;
511 :
512 0 : ret = drm_encoder_mode_valid(encoder, mode);
513 0 : if (ret != MODE_OK) {
514 0 : drm_dbg_atomic(encoder->dev,
515 : "[ENCODER:%d:%s] mode_valid() failed\n",
516 : encoder->base.id, encoder->name);
517 0 : return ret;
518 : }
519 :
520 0 : bridge = drm_bridge_chain_get_first_bridge(encoder);
521 0 : ret = drm_bridge_chain_mode_valid(bridge, &connector->display_info,
522 : mode);
523 0 : if (ret != MODE_OK) {
524 0 : drm_dbg_atomic(encoder->dev, "[BRIDGE] mode_valid() failed\n");
525 0 : return ret;
526 : }
527 :
528 0 : ret = drm_crtc_mode_valid(crtc, mode);
529 0 : if (ret != MODE_OK) {
530 0 : drm_dbg_atomic(encoder->dev, "[CRTC:%d:%s] mode_valid() failed\n",
531 : crtc->base.id, crtc->name);
532 0 : return ret;
533 : }
534 :
535 : return ret;
536 : }
537 :
538 : static int
539 0 : mode_valid(struct drm_atomic_state *state)
540 : {
541 : struct drm_connector_state *conn_state;
542 : struct drm_connector *connector;
543 : int i;
544 :
545 0 : for_each_new_connector_in_state(state, connector, conn_state, i) {
546 0 : struct drm_encoder *encoder = conn_state->best_encoder;
547 0 : struct drm_crtc *crtc = conn_state->crtc;
548 : struct drm_crtc_state *crtc_state;
549 : enum drm_mode_status mode_status;
550 : const struct drm_display_mode *mode;
551 :
552 0 : if (!crtc || !encoder)
553 0 : continue;
554 :
555 0 : crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
556 0 : if (!crtc_state)
557 0 : continue;
558 0 : if (!crtc_state->mode_changed && !crtc_state->connectors_changed)
559 0 : continue;
560 :
561 0 : mode = &crtc_state->mode;
562 :
563 0 : mode_status = mode_valid_path(connector, encoder, crtc, mode);
564 0 : if (mode_status != MODE_OK)
565 : return -EINVAL;
566 : }
567 :
568 : return 0;
569 : }
570 :
571 : /**
572 : * drm_atomic_helper_check_modeset - validate state object for modeset changes
573 : * @dev: DRM device
574 : * @state: the driver state object
575 : *
576 : * Check the state object to see if the requested state is physically possible.
577 : * This does all the CRTC and connector related computations for an atomic
578 : * update and adds any additional connectors needed for full modesets. It calls
579 : * the various per-object callbacks in the follow order:
580 : *
581 : * 1. &drm_connector_helper_funcs.atomic_best_encoder for determining the new encoder.
582 : * 2. &drm_connector_helper_funcs.atomic_check to validate the connector state.
583 : * 3. If it's determined a modeset is needed then all connectors on the affected
584 : * CRTC are added and &drm_connector_helper_funcs.atomic_check is run on them.
585 : * 4. &drm_encoder_helper_funcs.mode_valid, &drm_bridge_funcs.mode_valid and
586 : * &drm_crtc_helper_funcs.mode_valid are called on the affected components.
587 : * 5. &drm_bridge_funcs.mode_fixup is called on all encoder bridges.
588 : * 6. &drm_encoder_helper_funcs.atomic_check is called to validate any encoder state.
589 : * This function is only called when the encoder will be part of a configured CRTC,
590 : * it must not be used for implementing connector property validation.
591 : * If this function is NULL, &drm_atomic_encoder_helper_funcs.mode_fixup is called
592 : * instead.
593 : * 7. &drm_crtc_helper_funcs.mode_fixup is called last, to fix up the mode with CRTC constraints.
594 : *
595 : * &drm_crtc_state.mode_changed is set when the input mode is changed.
596 : * &drm_crtc_state.connectors_changed is set when a connector is added or
597 : * removed from the CRTC. &drm_crtc_state.active_changed is set when
598 : * &drm_crtc_state.active changes, which is used for DPMS.
599 : * &drm_crtc_state.no_vblank is set from the result of drm_dev_has_vblank().
600 : * See also: drm_atomic_crtc_needs_modeset()
601 : *
602 : * IMPORTANT:
603 : *
604 : * Drivers which set &drm_crtc_state.mode_changed (e.g. in their
605 : * &drm_plane_helper_funcs.atomic_check hooks if a plane update can't be done
606 : * without a full modeset) _must_ call this function after that change. It is
607 : * permitted to call this function multiple times for the same update, e.g.
608 : * when the &drm_crtc_helper_funcs.atomic_check functions depend upon the
609 : * adjusted dotclock for fifo space allocation and watermark computation.
610 : *
611 : * RETURNS:
612 : * Zero for success or -errno
613 : */
614 : int
615 0 : drm_atomic_helper_check_modeset(struct drm_device *dev,
616 : struct drm_atomic_state *state)
617 : {
618 : struct drm_crtc *crtc;
619 : struct drm_crtc_state *old_crtc_state, *new_crtc_state;
620 : struct drm_connector *connector;
621 : struct drm_connector_state *old_connector_state, *new_connector_state;
622 : int i, ret;
623 0 : unsigned int connectors_mask = 0;
624 :
625 0 : for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
626 0 : bool has_connectors =
627 0 : !!new_crtc_state->connector_mask;
628 :
629 0 : WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
630 :
631 0 : if (!drm_mode_equal(&old_crtc_state->mode, &new_crtc_state->mode)) {
632 0 : drm_dbg_atomic(dev, "[CRTC:%d:%s] mode changed\n",
633 : crtc->base.id, crtc->name);
634 0 : new_crtc_state->mode_changed = true;
635 : }
636 :
637 0 : if (old_crtc_state->enable != new_crtc_state->enable) {
638 0 : drm_dbg_atomic(dev, "[CRTC:%d:%s] enable changed\n",
639 : crtc->base.id, crtc->name);
640 :
641 : /*
642 : * For clarity this assignment is done here, but
643 : * enable == 0 is only true when there are no
644 : * connectors and a NULL mode.
645 : *
646 : * The other way around is true as well. enable != 0
647 : * implies that connectors are attached and a mode is set.
648 : */
649 0 : new_crtc_state->mode_changed = true;
650 0 : new_crtc_state->connectors_changed = true;
651 : }
652 :
653 0 : if (old_crtc_state->active != new_crtc_state->active) {
654 0 : drm_dbg_atomic(dev, "[CRTC:%d:%s] active changed\n",
655 : crtc->base.id, crtc->name);
656 0 : new_crtc_state->active_changed = true;
657 : }
658 :
659 0 : if (new_crtc_state->enable != has_connectors) {
660 0 : drm_dbg_atomic(dev, "[CRTC:%d:%s] enabled/connectors mismatch\n",
661 : crtc->base.id, crtc->name);
662 :
663 0 : return -EINVAL;
664 : }
665 :
666 0 : if (drm_dev_has_vblank(dev))
667 0 : new_crtc_state->no_vblank = false;
668 : else
669 0 : new_crtc_state->no_vblank = true;
670 : }
671 :
672 0 : ret = handle_conflicting_encoders(state, false);
673 0 : if (ret)
674 : return ret;
675 :
676 0 : for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i) {
677 0 : const struct drm_connector_helper_funcs *funcs = connector->helper_private;
678 :
679 0 : WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
680 :
681 : /*
682 : * This only sets crtc->connectors_changed for routing changes,
683 : * drivers must set crtc->connectors_changed themselves when
684 : * connector properties need to be updated.
685 : */
686 0 : ret = update_connector_routing(state, connector,
687 : old_connector_state,
688 : new_connector_state);
689 0 : if (ret)
690 : return ret;
691 0 : if (old_connector_state->crtc) {
692 0 : new_crtc_state = drm_atomic_get_new_crtc_state(state,
693 : old_connector_state->crtc);
694 0 : if (old_connector_state->link_status !=
695 0 : new_connector_state->link_status)
696 0 : new_crtc_state->connectors_changed = true;
697 :
698 0 : if (old_connector_state->max_requested_bpc !=
699 0 : new_connector_state->max_requested_bpc)
700 0 : new_crtc_state->connectors_changed = true;
701 : }
702 :
703 0 : if (funcs->atomic_check)
704 0 : ret = funcs->atomic_check(connector, state);
705 0 : if (ret) {
706 0 : drm_dbg_atomic(dev,
707 : "[CONNECTOR:%d:%s] driver check failed\n",
708 : connector->base.id, connector->name);
709 0 : return ret;
710 : }
711 :
712 0 : connectors_mask |= BIT(i);
713 : }
714 :
715 : /*
716 : * After all the routing has been prepared we need to add in any
717 : * connector which is itself unchanged, but whose CRTC changes its
718 : * configuration. This must be done before calling mode_fixup in case a
719 : * crtc only changed its mode but has the same set of connectors.
720 : */
721 0 : for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
722 0 : if (!drm_atomic_crtc_needs_modeset(new_crtc_state))
723 0 : continue;
724 :
725 0 : drm_dbg_atomic(dev,
726 : "[CRTC:%d:%s] needs all connectors, enable: %c, active: %c\n",
727 : crtc->base.id, crtc->name,
728 : new_crtc_state->enable ? 'y' : 'n',
729 : new_crtc_state->active ? 'y' : 'n');
730 :
731 0 : ret = drm_atomic_add_affected_connectors(state, crtc);
732 0 : if (ret != 0)
733 : return ret;
734 :
735 0 : ret = drm_atomic_add_affected_planes(state, crtc);
736 0 : if (ret != 0)
737 : return ret;
738 : }
739 :
740 : /*
741 : * Iterate over all connectors again, to make sure atomic_check()
742 : * has been called on them when a modeset is forced.
743 : */
744 0 : for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i) {
745 0 : const struct drm_connector_helper_funcs *funcs = connector->helper_private;
746 :
747 0 : if (connectors_mask & BIT(i))
748 0 : continue;
749 :
750 0 : if (funcs->atomic_check)
751 0 : ret = funcs->atomic_check(connector, state);
752 0 : if (ret) {
753 0 : drm_dbg_atomic(dev,
754 : "[CONNECTOR:%d:%s] driver check failed\n",
755 : connector->base.id, connector->name);
756 0 : return ret;
757 : }
758 : }
759 :
760 : /*
761 : * Iterate over all connectors again, and add all affected bridges to
762 : * the state.
763 : */
764 0 : for_each_oldnew_connector_in_state(state, connector,
765 : old_connector_state,
766 : new_connector_state, i) {
767 : struct drm_encoder *encoder;
768 :
769 0 : encoder = old_connector_state->best_encoder;
770 0 : ret = drm_atomic_add_encoder_bridges(state, encoder);
771 0 : if (ret)
772 : return ret;
773 :
774 0 : encoder = new_connector_state->best_encoder;
775 0 : ret = drm_atomic_add_encoder_bridges(state, encoder);
776 0 : if (ret)
777 : return ret;
778 : }
779 :
780 0 : ret = mode_valid(state);
781 0 : if (ret)
782 : return ret;
783 :
784 0 : return mode_fixup(state);
785 : }
786 : EXPORT_SYMBOL(drm_atomic_helper_check_modeset);
787 :
788 : /**
789 : * drm_atomic_helper_check_wb_encoder_state() - Check writeback encoder state
790 : * @encoder: encoder state to check
791 : * @conn_state: connector state to check
792 : *
793 : * Checks if the writeback connector state is valid, and returns an error if it
794 : * isn't.
795 : *
796 : * RETURNS:
797 : * Zero for success or -errno
798 : */
799 : int
800 0 : drm_atomic_helper_check_wb_encoder_state(struct drm_encoder *encoder,
801 : struct drm_connector_state *conn_state)
802 : {
803 0 : struct drm_writeback_job *wb_job = conn_state->writeback_job;
804 : struct drm_property_blob *pixel_format_blob;
805 : struct drm_framebuffer *fb;
806 : size_t i, nformats;
807 : u32 *formats;
808 :
809 0 : if (!wb_job || !wb_job->fb)
810 : return 0;
811 :
812 0 : pixel_format_blob = wb_job->connector->pixel_formats_blob_ptr;
813 0 : nformats = pixel_format_blob->length / sizeof(u32);
814 0 : formats = pixel_format_blob->data;
815 0 : fb = wb_job->fb;
816 :
817 0 : for (i = 0; i < nformats; i++)
818 0 : if (fb->format->format == formats[i])
819 : return 0;
820 :
821 0 : drm_dbg_kms(encoder->dev, "Invalid pixel format %p4cc\n", &fb->format->format);
822 :
823 0 : return -EINVAL;
824 : }
825 : EXPORT_SYMBOL(drm_atomic_helper_check_wb_encoder_state);
826 :
827 : /**
828 : * drm_atomic_helper_check_plane_state() - Check plane state for validity
829 : * @plane_state: plane state to check
830 : * @crtc_state: CRTC state to check
831 : * @min_scale: minimum @src:@dest scaling factor in 16.16 fixed point
832 : * @max_scale: maximum @src:@dest scaling factor in 16.16 fixed point
833 : * @can_position: is it legal to position the plane such that it
834 : * doesn't cover the entire CRTC? This will generally
835 : * only be false for primary planes.
836 : * @can_update_disabled: can the plane be updated while the CRTC
837 : * is disabled?
838 : *
839 : * Checks that a desired plane update is valid, and updates various
840 : * bits of derived state (clipped coordinates etc.). Drivers that provide
841 : * their own plane handling rather than helper-provided implementations may
842 : * still wish to call this function to avoid duplication of error checking
843 : * code.
844 : *
845 : * RETURNS:
846 : * Zero if update appears valid, error code on failure
847 : */
848 12 : int drm_atomic_helper_check_plane_state(struct drm_plane_state *plane_state,
849 : const struct drm_crtc_state *crtc_state,
850 : int min_scale,
851 : int max_scale,
852 : bool can_position,
853 : bool can_update_disabled)
854 : {
855 12 : struct drm_framebuffer *fb = plane_state->fb;
856 12 : struct drm_rect *src = &plane_state->src;
857 12 : struct drm_rect *dst = &plane_state->dst;
858 12 : unsigned int rotation = plane_state->rotation;
859 12 : struct drm_rect clip = {};
860 : int hscale, vscale;
861 :
862 12 : WARN_ON(plane_state->crtc && plane_state->crtc != crtc_state->crtc);
863 :
864 24 : *src = drm_plane_state_src(plane_state);
865 24 : *dst = drm_plane_state_dest(plane_state);
866 :
867 12 : if (!fb) {
868 0 : plane_state->visible = false;
869 0 : return 0;
870 : }
871 :
872 : /* crtc should only be NULL when disabling (i.e., !fb) */
873 12 : if (WARN_ON(!plane_state->crtc)) {
874 0 : plane_state->visible = false;
875 0 : return 0;
876 : }
877 :
878 12 : if (!crtc_state->enable && !can_update_disabled) {
879 0 : drm_dbg_kms(plane_state->plane->dev,
880 : "Cannot update plane of a disabled CRTC.\n");
881 0 : return -EINVAL;
882 : }
883 :
884 12 : drm_rect_rotate(src, fb->width << 16, fb->height << 16, rotation);
885 :
886 : /* Check scaling */
887 12 : hscale = drm_rect_calc_hscale(src, dst, min_scale, max_scale);
888 12 : vscale = drm_rect_calc_vscale(src, dst, min_scale, max_scale);
889 12 : if (hscale < 0 || vscale < 0) {
890 2 : drm_dbg_kms(plane_state->plane->dev,
891 : "Invalid scaling of plane\n");
892 2 : drm_rect_debug_print("src: ", &plane_state->src, true);
893 2 : drm_rect_debug_print("dst: ", &plane_state->dst, false);
894 2 : return -ERANGE;
895 : }
896 :
897 10 : if (crtc_state->enable)
898 10 : drm_mode_get_hv_timing(&crtc_state->mode, &clip.x2, &clip.y2);
899 :
900 10 : plane_state->visible = drm_rect_clip_scaled(src, dst, &clip);
901 :
902 10 : drm_rect_rotate_inv(src, fb->width << 16, fb->height << 16, rotation);
903 :
904 10 : if (!plane_state->visible)
905 : /*
906 : * Plane isn't visible; some drivers can handle this
907 : * so we just return success here. Drivers that can't
908 : * (including those that use the primary plane helper's
909 : * update function) will return an error from their
910 : * update_plane handler.
911 : */
912 : return 0;
913 :
914 17 : if (!can_position && !drm_rect_equals(dst, &clip)) {
915 1 : drm_dbg_kms(plane_state->plane->dev,
916 : "Plane must cover entire CRTC\n");
917 1 : drm_rect_debug_print("dst: ", dst, false);
918 1 : drm_rect_debug_print("clip: ", &clip, false);
919 1 : return -EINVAL;
920 : }
921 :
922 : return 0;
923 : }
924 : EXPORT_SYMBOL(drm_atomic_helper_check_plane_state);
925 :
926 : /**
927 : * drm_atomic_helper_check_crtc_primary_plane() - Check CRTC state for primary plane
928 : * @crtc_state: CRTC state to check
929 : *
930 : * Checks that a CRTC has at least one primary plane attached to it, which is
931 : * a requirement on some hardware. Note that this only involves the CRTC side
932 : * of the test. To test if the primary plane is visible or if it can be updated
933 : * without the CRTC being enabled, use drm_atomic_helper_check_plane_state() in
934 : * the plane's atomic check.
935 : *
936 : * RETURNS:
937 : * 0 if a primary plane is attached to the CRTC, or an error code otherwise
938 : */
939 0 : int drm_atomic_helper_check_crtc_primary_plane(struct drm_crtc_state *crtc_state)
940 : {
941 0 : struct drm_crtc *crtc = crtc_state->crtc;
942 0 : struct drm_device *dev = crtc->dev;
943 : struct drm_plane *plane;
944 :
945 : /* needs at least one primary plane to be enabled */
946 0 : drm_for_each_plane_mask(plane, dev, crtc_state->plane_mask) {
947 0 : if (plane->type == DRM_PLANE_TYPE_PRIMARY)
948 : return 0;
949 : }
950 :
951 0 : drm_dbg_atomic(dev, "[CRTC:%d:%s] primary plane missing\n", crtc->base.id, crtc->name);
952 :
953 0 : return -EINVAL;
954 : }
955 : EXPORT_SYMBOL(drm_atomic_helper_check_crtc_primary_plane);
956 :
957 : /**
958 : * drm_atomic_helper_check_planes - validate state object for planes changes
959 : * @dev: DRM device
960 : * @state: the driver state object
961 : *
962 : * Check the state object to see if the requested state is physically possible.
963 : * This does all the plane update related checks using by calling into the
964 : * &drm_crtc_helper_funcs.atomic_check and &drm_plane_helper_funcs.atomic_check
965 : * hooks provided by the driver.
966 : *
967 : * It also sets &drm_crtc_state.planes_changed to indicate that a CRTC has
968 : * updated planes.
969 : *
970 : * RETURNS:
971 : * Zero for success or -errno
972 : */
973 : int
974 0 : drm_atomic_helper_check_planes(struct drm_device *dev,
975 : struct drm_atomic_state *state)
976 : {
977 : struct drm_crtc *crtc;
978 : struct drm_crtc_state *new_crtc_state;
979 : struct drm_plane *plane;
980 : struct drm_plane_state *new_plane_state, *old_plane_state;
981 0 : int i, ret = 0;
982 :
983 0 : for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
984 : const struct drm_plane_helper_funcs *funcs;
985 :
986 0 : WARN_ON(!drm_modeset_is_locked(&plane->mutex));
987 :
988 0 : funcs = plane->helper_private;
989 :
990 0 : drm_atomic_helper_plane_changed(state, old_plane_state, new_plane_state, plane);
991 :
992 0 : drm_atomic_helper_check_plane_damage(state, new_plane_state);
993 :
994 0 : if (!funcs || !funcs->atomic_check)
995 0 : continue;
996 :
997 0 : ret = funcs->atomic_check(plane, state);
998 0 : if (ret) {
999 0 : drm_dbg_atomic(plane->dev,
1000 : "[PLANE:%d:%s] atomic driver check failed\n",
1001 : plane->base.id, plane->name);
1002 0 : return ret;
1003 : }
1004 : }
1005 :
1006 0 : for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
1007 : const struct drm_crtc_helper_funcs *funcs;
1008 :
1009 0 : funcs = crtc->helper_private;
1010 :
1011 0 : if (!funcs || !funcs->atomic_check)
1012 0 : continue;
1013 :
1014 0 : ret = funcs->atomic_check(crtc, state);
1015 0 : if (ret) {
1016 0 : drm_dbg_atomic(crtc->dev,
1017 : "[CRTC:%d:%s] atomic driver check failed\n",
1018 : crtc->base.id, crtc->name);
1019 0 : return ret;
1020 : }
1021 : }
1022 :
1023 : return ret;
1024 : }
1025 : EXPORT_SYMBOL(drm_atomic_helper_check_planes);
1026 :
1027 : /**
1028 : * drm_atomic_helper_check - validate state object
1029 : * @dev: DRM device
1030 : * @state: the driver state object
1031 : *
1032 : * Check the state object to see if the requested state is physically possible.
1033 : * Only CRTCs and planes have check callbacks, so for any additional (global)
1034 : * checking that a driver needs it can simply wrap that around this function.
1035 : * Drivers without such needs can directly use this as their
1036 : * &drm_mode_config_funcs.atomic_check callback.
1037 : *
1038 : * This just wraps the two parts of the state checking for planes and modeset
1039 : * state in the default order: First it calls drm_atomic_helper_check_modeset()
1040 : * and then drm_atomic_helper_check_planes(). The assumption is that the
1041 : * @drm_plane_helper_funcs.atomic_check and @drm_crtc_helper_funcs.atomic_check
1042 : * functions depend upon an updated adjusted_mode.clock to e.g. properly compute
1043 : * watermarks.
1044 : *
1045 : * Note that zpos normalization will add all enable planes to the state which
1046 : * might not desired for some drivers.
1047 : * For example enable/disable of a cursor plane which have fixed zpos value
1048 : * would trigger all other enabled planes to be forced to the state change.
1049 : *
1050 : * RETURNS:
1051 : * Zero for success or -errno
1052 : */
1053 0 : int drm_atomic_helper_check(struct drm_device *dev,
1054 : struct drm_atomic_state *state)
1055 : {
1056 : int ret;
1057 :
1058 0 : ret = drm_atomic_helper_check_modeset(dev, state);
1059 0 : if (ret)
1060 : return ret;
1061 :
1062 0 : if (dev->mode_config.normalize_zpos) {
1063 0 : ret = drm_atomic_normalize_zpos(dev, state);
1064 0 : if (ret)
1065 : return ret;
1066 : }
1067 :
1068 0 : ret = drm_atomic_helper_check_planes(dev, state);
1069 0 : if (ret)
1070 : return ret;
1071 :
1072 0 : if (state->legacy_cursor_update)
1073 0 : state->async_update = !drm_atomic_helper_async_check(dev, state);
1074 :
1075 0 : drm_self_refresh_helper_alter_state(state);
1076 :
1077 0 : return ret;
1078 : }
1079 : EXPORT_SYMBOL(drm_atomic_helper_check);
1080 :
1081 : static bool
1082 0 : crtc_needs_disable(struct drm_crtc_state *old_state,
1083 : struct drm_crtc_state *new_state)
1084 : {
1085 : /*
1086 : * No new_state means the CRTC is off, so the only criteria is whether
1087 : * it's currently active or in self refresh mode.
1088 : */
1089 0 : if (!new_state)
1090 0 : return drm_atomic_crtc_effectively_active(old_state);
1091 :
1092 : /*
1093 : * We need to disable bridge(s) and CRTC if we're transitioning out of
1094 : * self-refresh and changing CRTCs at the same time, because the
1095 : * bridge tracks self-refresh status via CRTC state.
1096 : */
1097 0 : if (old_state->self_refresh_active &&
1098 0 : old_state->crtc != new_state->crtc)
1099 : return true;
1100 :
1101 : /*
1102 : * We also need to run through the crtc_funcs->disable() function if
1103 : * the CRTC is currently on, if it's transitioning to self refresh
1104 : * mode, or if it's in self refresh mode and needs to be fully
1105 : * disabled.
1106 : */
1107 0 : return old_state->active ||
1108 0 : (old_state->self_refresh_active && !new_state->active) ||
1109 0 : new_state->self_refresh_active;
1110 : }
1111 :
1112 : static void
1113 0 : disable_outputs(struct drm_device *dev, struct drm_atomic_state *old_state)
1114 : {
1115 : struct drm_connector *connector;
1116 : struct drm_connector_state *old_conn_state, *new_conn_state;
1117 : struct drm_crtc *crtc;
1118 : struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1119 : int i;
1120 :
1121 0 : for_each_oldnew_connector_in_state(old_state, connector, old_conn_state, new_conn_state, i) {
1122 : const struct drm_encoder_helper_funcs *funcs;
1123 : struct drm_encoder *encoder;
1124 : struct drm_bridge *bridge;
1125 :
1126 : /*
1127 : * Shut down everything that's in the changeset and currently
1128 : * still on. So need to check the old, saved state.
1129 : */
1130 0 : if (!old_conn_state->crtc)
1131 0 : continue;
1132 :
1133 0 : old_crtc_state = drm_atomic_get_old_crtc_state(old_state, old_conn_state->crtc);
1134 :
1135 0 : if (new_conn_state->crtc)
1136 0 : new_crtc_state = drm_atomic_get_new_crtc_state(
1137 : old_state,
1138 : new_conn_state->crtc);
1139 : else
1140 : new_crtc_state = NULL;
1141 :
1142 0 : if (!crtc_needs_disable(old_crtc_state, new_crtc_state) ||
1143 0 : !drm_atomic_crtc_needs_modeset(old_conn_state->crtc->state))
1144 0 : continue;
1145 :
1146 0 : encoder = old_conn_state->best_encoder;
1147 :
1148 : /* We shouldn't get this far if we didn't previously have
1149 : * an encoder.. but WARN_ON() rather than explode.
1150 : */
1151 0 : if (WARN_ON(!encoder))
1152 0 : continue;
1153 :
1154 0 : funcs = encoder->helper_private;
1155 :
1156 0 : drm_dbg_atomic(dev, "disabling [ENCODER:%d:%s]\n",
1157 : encoder->base.id, encoder->name);
1158 :
1159 : /*
1160 : * Each encoder has at most one connector (since we always steal
1161 : * it away), so we won't call disable hooks twice.
1162 : */
1163 0 : bridge = drm_bridge_chain_get_first_bridge(encoder);
1164 0 : drm_atomic_bridge_chain_disable(bridge, old_state);
1165 :
1166 : /* Right function depends upon target state. */
1167 0 : if (funcs) {
1168 0 : if (funcs->atomic_disable)
1169 0 : funcs->atomic_disable(encoder, old_state);
1170 0 : else if (new_conn_state->crtc && funcs->prepare)
1171 0 : funcs->prepare(encoder);
1172 0 : else if (funcs->disable)
1173 0 : funcs->disable(encoder);
1174 0 : else if (funcs->dpms)
1175 0 : funcs->dpms(encoder, DRM_MODE_DPMS_OFF);
1176 : }
1177 :
1178 0 : drm_atomic_bridge_chain_post_disable(bridge, old_state);
1179 : }
1180 :
1181 0 : for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1182 : const struct drm_crtc_helper_funcs *funcs;
1183 : int ret;
1184 :
1185 : /* Shut down everything that needs a full modeset. */
1186 0 : if (!drm_atomic_crtc_needs_modeset(new_crtc_state))
1187 0 : continue;
1188 :
1189 0 : if (!crtc_needs_disable(old_crtc_state, new_crtc_state))
1190 0 : continue;
1191 :
1192 0 : funcs = crtc->helper_private;
1193 :
1194 0 : drm_dbg_atomic(dev, "disabling [CRTC:%d:%s]\n",
1195 : crtc->base.id, crtc->name);
1196 :
1197 :
1198 : /* Right function depends upon target state. */
1199 0 : if (new_crtc_state->enable && funcs->prepare)
1200 0 : funcs->prepare(crtc);
1201 0 : else if (funcs->atomic_disable)
1202 0 : funcs->atomic_disable(crtc, old_state);
1203 0 : else if (funcs->disable)
1204 0 : funcs->disable(crtc);
1205 0 : else if (funcs->dpms)
1206 0 : funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
1207 :
1208 0 : if (!drm_dev_has_vblank(dev))
1209 0 : continue;
1210 :
1211 0 : ret = drm_crtc_vblank_get(crtc);
1212 : /*
1213 : * Self-refresh is not a true "disable"; ensure vblank remains
1214 : * enabled.
1215 : */
1216 0 : if (new_crtc_state->self_refresh_active)
1217 0 : WARN_ONCE(ret != 0,
1218 : "driver disabled vblank in self-refresh\n");
1219 : else
1220 0 : WARN_ONCE(ret != -EINVAL,
1221 : "driver forgot to call drm_crtc_vblank_off()\n");
1222 0 : if (ret == 0)
1223 0 : drm_crtc_vblank_put(crtc);
1224 : }
1225 0 : }
1226 :
1227 : /**
1228 : * drm_atomic_helper_update_legacy_modeset_state - update legacy modeset state
1229 : * @dev: DRM device
1230 : * @old_state: atomic state object with old state structures
1231 : *
1232 : * This function updates all the various legacy modeset state pointers in
1233 : * connectors, encoders and CRTCs.
1234 : *
1235 : * Drivers can use this for building their own atomic commit if they don't have
1236 : * a pure helper-based modeset implementation.
1237 : *
1238 : * Since these updates are not synchronized with lockings, only code paths
1239 : * called from &drm_mode_config_helper_funcs.atomic_commit_tail can look at the
1240 : * legacy state filled out by this helper. Defacto this means this helper and
1241 : * the legacy state pointers are only really useful for transitioning an
1242 : * existing driver to the atomic world.
1243 : */
1244 : void
1245 0 : drm_atomic_helper_update_legacy_modeset_state(struct drm_device *dev,
1246 : struct drm_atomic_state *old_state)
1247 : {
1248 : struct drm_connector *connector;
1249 : struct drm_connector_state *old_conn_state, *new_conn_state;
1250 : struct drm_crtc *crtc;
1251 : struct drm_crtc_state *new_crtc_state;
1252 : int i;
1253 :
1254 : /* clear out existing links and update dpms */
1255 0 : for_each_oldnew_connector_in_state(old_state, connector, old_conn_state, new_conn_state, i) {
1256 0 : if (connector->encoder) {
1257 0 : WARN_ON(!connector->encoder->crtc);
1258 :
1259 0 : connector->encoder->crtc = NULL;
1260 0 : connector->encoder = NULL;
1261 : }
1262 :
1263 0 : crtc = new_conn_state->crtc;
1264 0 : if ((!crtc && old_conn_state->crtc) ||
1265 0 : (crtc && drm_atomic_crtc_needs_modeset(crtc->state))) {
1266 0 : int mode = DRM_MODE_DPMS_OFF;
1267 :
1268 0 : if (crtc && crtc->state->active)
1269 0 : mode = DRM_MODE_DPMS_ON;
1270 :
1271 0 : connector->dpms = mode;
1272 : }
1273 : }
1274 :
1275 : /* set new links */
1276 0 : for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1277 0 : if (!new_conn_state->crtc)
1278 0 : continue;
1279 :
1280 0 : if (WARN_ON(!new_conn_state->best_encoder))
1281 0 : continue;
1282 :
1283 0 : connector->encoder = new_conn_state->best_encoder;
1284 0 : connector->encoder->crtc = new_conn_state->crtc;
1285 : }
1286 :
1287 : /* set legacy state in the crtc structure */
1288 0 : for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
1289 0 : struct drm_plane *primary = crtc->primary;
1290 : struct drm_plane_state *new_plane_state;
1291 :
1292 0 : crtc->mode = new_crtc_state->mode;
1293 0 : crtc->enabled = new_crtc_state->enable;
1294 :
1295 0 : new_plane_state =
1296 : drm_atomic_get_new_plane_state(old_state, primary);
1297 :
1298 0 : if (new_plane_state && new_plane_state->crtc == crtc) {
1299 0 : crtc->x = new_plane_state->src_x >> 16;
1300 0 : crtc->y = new_plane_state->src_y >> 16;
1301 : }
1302 : }
1303 0 : }
1304 : EXPORT_SYMBOL(drm_atomic_helper_update_legacy_modeset_state);
1305 :
1306 : /**
1307 : * drm_atomic_helper_calc_timestamping_constants - update vblank timestamping constants
1308 : * @state: atomic state object
1309 : *
1310 : * Updates the timestamping constants used for precise vblank timestamps
1311 : * by calling drm_calc_timestamping_constants() for all enabled crtcs in @state.
1312 : */
1313 0 : void drm_atomic_helper_calc_timestamping_constants(struct drm_atomic_state *state)
1314 : {
1315 : struct drm_crtc_state *new_crtc_state;
1316 : struct drm_crtc *crtc;
1317 : int i;
1318 :
1319 0 : for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
1320 0 : if (new_crtc_state->enable)
1321 0 : drm_calc_timestamping_constants(crtc,
1322 0 : &new_crtc_state->adjusted_mode);
1323 : }
1324 0 : }
1325 : EXPORT_SYMBOL(drm_atomic_helper_calc_timestamping_constants);
1326 :
1327 : static void
1328 0 : crtc_set_mode(struct drm_device *dev, struct drm_atomic_state *old_state)
1329 : {
1330 : struct drm_crtc *crtc;
1331 : struct drm_crtc_state *new_crtc_state;
1332 : struct drm_connector *connector;
1333 : struct drm_connector_state *new_conn_state;
1334 : int i;
1335 :
1336 0 : for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
1337 : const struct drm_crtc_helper_funcs *funcs;
1338 :
1339 0 : if (!new_crtc_state->mode_changed)
1340 0 : continue;
1341 :
1342 0 : funcs = crtc->helper_private;
1343 :
1344 0 : if (new_crtc_state->enable && funcs->mode_set_nofb) {
1345 0 : drm_dbg_atomic(dev, "modeset on [CRTC:%d:%s]\n",
1346 : crtc->base.id, crtc->name);
1347 :
1348 0 : funcs->mode_set_nofb(crtc);
1349 : }
1350 : }
1351 :
1352 0 : for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1353 : const struct drm_encoder_helper_funcs *funcs;
1354 : struct drm_encoder *encoder;
1355 : struct drm_display_mode *mode, *adjusted_mode;
1356 : struct drm_bridge *bridge;
1357 :
1358 0 : if (!new_conn_state->best_encoder)
1359 0 : continue;
1360 :
1361 0 : encoder = new_conn_state->best_encoder;
1362 0 : funcs = encoder->helper_private;
1363 0 : new_crtc_state = new_conn_state->crtc->state;
1364 0 : mode = &new_crtc_state->mode;
1365 0 : adjusted_mode = &new_crtc_state->adjusted_mode;
1366 :
1367 0 : if (!new_crtc_state->mode_changed)
1368 0 : continue;
1369 :
1370 0 : drm_dbg_atomic(dev, "modeset on [ENCODER:%d:%s]\n",
1371 : encoder->base.id, encoder->name);
1372 :
1373 : /*
1374 : * Each encoder has at most one connector (since we always steal
1375 : * it away), so we won't call mode_set hooks twice.
1376 : */
1377 0 : if (funcs && funcs->atomic_mode_set) {
1378 0 : funcs->atomic_mode_set(encoder, new_crtc_state,
1379 : new_conn_state);
1380 0 : } else if (funcs && funcs->mode_set) {
1381 0 : funcs->mode_set(encoder, mode, adjusted_mode);
1382 : }
1383 :
1384 0 : bridge = drm_bridge_chain_get_first_bridge(encoder);
1385 0 : drm_bridge_chain_mode_set(bridge, mode, adjusted_mode);
1386 : }
1387 0 : }
1388 :
1389 : /**
1390 : * drm_atomic_helper_commit_modeset_disables - modeset commit to disable outputs
1391 : * @dev: DRM device
1392 : * @old_state: atomic state object with old state structures
1393 : *
1394 : * This function shuts down all the outputs that need to be shut down and
1395 : * prepares them (if required) with the new mode.
1396 : *
1397 : * For compatibility with legacy CRTC helpers this should be called before
1398 : * drm_atomic_helper_commit_planes(), which is what the default commit function
1399 : * does. But drivers with different needs can group the modeset commits together
1400 : * and do the plane commits at the end. This is useful for drivers doing runtime
1401 : * PM since planes updates then only happen when the CRTC is actually enabled.
1402 : */
1403 0 : void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev,
1404 : struct drm_atomic_state *old_state)
1405 : {
1406 0 : disable_outputs(dev, old_state);
1407 :
1408 0 : drm_atomic_helper_update_legacy_modeset_state(dev, old_state);
1409 0 : drm_atomic_helper_calc_timestamping_constants(old_state);
1410 :
1411 0 : crtc_set_mode(dev, old_state);
1412 0 : }
1413 : EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_disables);
1414 :
1415 0 : static void drm_atomic_helper_commit_writebacks(struct drm_device *dev,
1416 : struct drm_atomic_state *old_state)
1417 : {
1418 : struct drm_connector *connector;
1419 : struct drm_connector_state *new_conn_state;
1420 : int i;
1421 :
1422 0 : for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1423 : const struct drm_connector_helper_funcs *funcs;
1424 :
1425 0 : funcs = connector->helper_private;
1426 0 : if (!funcs->atomic_commit)
1427 0 : continue;
1428 :
1429 0 : if (new_conn_state->writeback_job && new_conn_state->writeback_job->fb) {
1430 0 : WARN_ON(connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK);
1431 0 : funcs->atomic_commit(connector, old_state);
1432 : }
1433 : }
1434 0 : }
1435 :
1436 : /**
1437 : * drm_atomic_helper_commit_modeset_enables - modeset commit to enable outputs
1438 : * @dev: DRM device
1439 : * @old_state: atomic state object with old state structures
1440 : *
1441 : * This function enables all the outputs with the new configuration which had to
1442 : * be turned off for the update.
1443 : *
1444 : * For compatibility with legacy CRTC helpers this should be called after
1445 : * drm_atomic_helper_commit_planes(), which is what the default commit function
1446 : * does. But drivers with different needs can group the modeset commits together
1447 : * and do the plane commits at the end. This is useful for drivers doing runtime
1448 : * PM since planes updates then only happen when the CRTC is actually enabled.
1449 : */
1450 0 : void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev,
1451 : struct drm_atomic_state *old_state)
1452 : {
1453 : struct drm_crtc *crtc;
1454 : struct drm_crtc_state *old_crtc_state;
1455 : struct drm_crtc_state *new_crtc_state;
1456 : struct drm_connector *connector;
1457 : struct drm_connector_state *new_conn_state;
1458 : int i;
1459 :
1460 0 : for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1461 : const struct drm_crtc_helper_funcs *funcs;
1462 :
1463 : /* Need to filter out CRTCs where only planes change. */
1464 0 : if (!drm_atomic_crtc_needs_modeset(new_crtc_state))
1465 0 : continue;
1466 :
1467 0 : if (!new_crtc_state->active)
1468 0 : continue;
1469 :
1470 0 : funcs = crtc->helper_private;
1471 :
1472 0 : if (new_crtc_state->enable) {
1473 0 : drm_dbg_atomic(dev, "enabling [CRTC:%d:%s]\n",
1474 : crtc->base.id, crtc->name);
1475 0 : if (funcs->atomic_enable)
1476 0 : funcs->atomic_enable(crtc, old_state);
1477 0 : else if (funcs->commit)
1478 0 : funcs->commit(crtc);
1479 : }
1480 : }
1481 :
1482 0 : for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1483 : const struct drm_encoder_helper_funcs *funcs;
1484 : struct drm_encoder *encoder;
1485 : struct drm_bridge *bridge;
1486 :
1487 0 : if (!new_conn_state->best_encoder)
1488 0 : continue;
1489 :
1490 0 : if (!new_conn_state->crtc->state->active ||
1491 0 : !drm_atomic_crtc_needs_modeset(new_conn_state->crtc->state))
1492 0 : continue;
1493 :
1494 0 : encoder = new_conn_state->best_encoder;
1495 0 : funcs = encoder->helper_private;
1496 :
1497 0 : drm_dbg_atomic(dev, "enabling [ENCODER:%d:%s]\n",
1498 : encoder->base.id, encoder->name);
1499 :
1500 : /*
1501 : * Each encoder has at most one connector (since we always steal
1502 : * it away), so we won't call enable hooks twice.
1503 : */
1504 0 : bridge = drm_bridge_chain_get_first_bridge(encoder);
1505 0 : drm_atomic_bridge_chain_pre_enable(bridge, old_state);
1506 :
1507 0 : if (funcs) {
1508 0 : if (funcs->atomic_enable)
1509 0 : funcs->atomic_enable(encoder, old_state);
1510 0 : else if (funcs->enable)
1511 0 : funcs->enable(encoder);
1512 0 : else if (funcs->commit)
1513 0 : funcs->commit(encoder);
1514 : }
1515 :
1516 0 : drm_atomic_bridge_chain_enable(bridge, old_state);
1517 : }
1518 :
1519 0 : drm_atomic_helper_commit_writebacks(dev, old_state);
1520 0 : }
1521 : EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables);
1522 :
1523 : /*
1524 : * For atomic updates which touch just a single CRTC, calculate the time of the
1525 : * next vblank, and inform all the fences of the deadline.
1526 : */
1527 0 : static void set_fence_deadline(struct drm_device *dev,
1528 : struct drm_atomic_state *state)
1529 : {
1530 : struct drm_crtc *crtc;
1531 : struct drm_crtc_state *new_crtc_state;
1532 : struct drm_plane *plane;
1533 : struct drm_plane_state *new_plane_state;
1534 0 : ktime_t vbltime = 0;
1535 : int i;
1536 :
1537 0 : for_each_new_crtc_in_state (state, crtc, new_crtc_state, i) {
1538 : ktime_t v;
1539 :
1540 0 : if (drm_atomic_crtc_needs_modeset(new_crtc_state))
1541 0 : continue;
1542 :
1543 0 : if (!new_crtc_state->active)
1544 0 : continue;
1545 :
1546 0 : if (drm_crtc_next_vblank_start(crtc, &v))
1547 0 : continue;
1548 :
1549 0 : if (!vbltime || ktime_before(v, vbltime))
1550 0 : vbltime = v;
1551 : }
1552 :
1553 : /* If no CRTCs updated, then nothing to do: */
1554 0 : if (!vbltime)
1555 : return;
1556 :
1557 0 : for_each_new_plane_in_state (state, plane, new_plane_state, i) {
1558 0 : if (!new_plane_state->fence)
1559 0 : continue;
1560 0 : dma_fence_set_deadline(new_plane_state->fence, vbltime);
1561 : }
1562 : }
1563 :
1564 : /**
1565 : * drm_atomic_helper_wait_for_fences - wait for fences stashed in plane state
1566 : * @dev: DRM device
1567 : * @state: atomic state object with old state structures
1568 : * @pre_swap: If true, do an interruptible wait, and @state is the new state.
1569 : * Otherwise @state is the old state.
1570 : *
1571 : * For implicit sync, driver should fish the exclusive fence out from the
1572 : * incoming fb's and stash it in the drm_plane_state. This is called after
1573 : * drm_atomic_helper_swap_state() so it uses the current plane state (and
1574 : * just uses the atomic state to find the changed planes)
1575 : *
1576 : * Note that @pre_swap is needed since the point where we block for fences moves
1577 : * around depending upon whether an atomic commit is blocking or
1578 : * non-blocking. For non-blocking commit all waiting needs to happen after
1579 : * drm_atomic_helper_swap_state() is called, but for blocking commits we want
1580 : * to wait **before** we do anything that can't be easily rolled back. That is
1581 : * before we call drm_atomic_helper_swap_state().
1582 : *
1583 : * Returns zero if success or < 0 if dma_fence_wait() fails.
1584 : */
1585 0 : int drm_atomic_helper_wait_for_fences(struct drm_device *dev,
1586 : struct drm_atomic_state *state,
1587 : bool pre_swap)
1588 : {
1589 : struct drm_plane *plane;
1590 : struct drm_plane_state *new_plane_state;
1591 : int i, ret;
1592 :
1593 0 : set_fence_deadline(dev, state);
1594 :
1595 0 : for_each_new_plane_in_state(state, plane, new_plane_state, i) {
1596 0 : if (!new_plane_state->fence)
1597 0 : continue;
1598 :
1599 0 : WARN_ON(!new_plane_state->fb);
1600 :
1601 : /*
1602 : * If waiting for fences pre-swap (ie: nonblock), userspace can
1603 : * still interrupt the operation. Instead of blocking until the
1604 : * timer expires, make the wait interruptible.
1605 : */
1606 0 : ret = dma_fence_wait(new_plane_state->fence, pre_swap);
1607 0 : if (ret)
1608 : return ret;
1609 :
1610 0 : dma_fence_put(new_plane_state->fence);
1611 0 : new_plane_state->fence = NULL;
1612 : }
1613 :
1614 : return 0;
1615 : }
1616 : EXPORT_SYMBOL(drm_atomic_helper_wait_for_fences);
1617 :
1618 : /**
1619 : * drm_atomic_helper_wait_for_vblanks - wait for vblank on CRTCs
1620 : * @dev: DRM device
1621 : * @old_state: atomic state object with old state structures
1622 : *
1623 : * Helper to, after atomic commit, wait for vblanks on all affected
1624 : * CRTCs (ie. before cleaning up old framebuffers using
1625 : * drm_atomic_helper_cleanup_planes()). It will only wait on CRTCs where the
1626 : * framebuffers have actually changed to optimize for the legacy cursor and
1627 : * plane update use-case.
1628 : *
1629 : * Drivers using the nonblocking commit tracking support initialized by calling
1630 : * drm_atomic_helper_setup_commit() should look at
1631 : * drm_atomic_helper_wait_for_flip_done() as an alternative.
1632 : */
1633 : void
1634 0 : drm_atomic_helper_wait_for_vblanks(struct drm_device *dev,
1635 : struct drm_atomic_state *old_state)
1636 : {
1637 : struct drm_crtc *crtc;
1638 : struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1639 : int i, ret;
1640 0 : unsigned int crtc_mask = 0;
1641 :
1642 : /*
1643 : * Legacy cursor ioctls are completely unsynced, and userspace
1644 : * relies on that (by doing tons of cursor updates).
1645 : */
1646 0 : if (old_state->legacy_cursor_update)
1647 : return;
1648 :
1649 0 : for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1650 0 : if (!new_crtc_state->active)
1651 0 : continue;
1652 :
1653 0 : ret = drm_crtc_vblank_get(crtc);
1654 0 : if (ret != 0)
1655 0 : continue;
1656 :
1657 0 : crtc_mask |= drm_crtc_mask(crtc);
1658 0 : old_state->crtcs[i].last_vblank_count = drm_crtc_vblank_count(crtc);
1659 : }
1660 :
1661 0 : for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1662 0 : if (!(crtc_mask & drm_crtc_mask(crtc)))
1663 0 : continue;
1664 :
1665 0 : ret = wait_event_timeout(dev->vblank[i].queue,
1666 : old_state->crtcs[i].last_vblank_count !=
1667 : drm_crtc_vblank_count(crtc),
1668 : msecs_to_jiffies(100));
1669 :
1670 0 : WARN(!ret, "[CRTC:%d:%s] vblank wait timed out\n",
1671 : crtc->base.id, crtc->name);
1672 :
1673 0 : drm_crtc_vblank_put(crtc);
1674 : }
1675 : }
1676 : EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks);
1677 :
1678 : /**
1679 : * drm_atomic_helper_wait_for_flip_done - wait for all page flips to be done
1680 : * @dev: DRM device
1681 : * @old_state: atomic state object with old state structures
1682 : *
1683 : * Helper to, after atomic commit, wait for page flips on all affected
1684 : * crtcs (ie. before cleaning up old framebuffers using
1685 : * drm_atomic_helper_cleanup_planes()). Compared to
1686 : * drm_atomic_helper_wait_for_vblanks() this waits for the completion on all
1687 : * CRTCs, assuming that cursors-only updates are signalling their completion
1688 : * immediately (or using a different path).
1689 : *
1690 : * This requires that drivers use the nonblocking commit tracking support
1691 : * initialized using drm_atomic_helper_setup_commit().
1692 : */
1693 0 : void drm_atomic_helper_wait_for_flip_done(struct drm_device *dev,
1694 : struct drm_atomic_state *old_state)
1695 : {
1696 : struct drm_crtc *crtc;
1697 : int i;
1698 :
1699 0 : for (i = 0; i < dev->mode_config.num_crtc; i++) {
1700 0 : struct drm_crtc_commit *commit = old_state->crtcs[i].commit;
1701 : int ret;
1702 :
1703 0 : crtc = old_state->crtcs[i].ptr;
1704 :
1705 0 : if (!crtc || !commit)
1706 0 : continue;
1707 :
1708 0 : ret = wait_for_completion_timeout(&commit->flip_done, 10 * HZ);
1709 0 : if (ret == 0)
1710 0 : drm_err(dev, "[CRTC:%d:%s] flip_done timed out\n",
1711 : crtc->base.id, crtc->name);
1712 : }
1713 :
1714 0 : if (old_state->fake_commit)
1715 0 : complete_all(&old_state->fake_commit->flip_done);
1716 0 : }
1717 : EXPORT_SYMBOL(drm_atomic_helper_wait_for_flip_done);
1718 :
1719 : /**
1720 : * drm_atomic_helper_commit_tail - commit atomic update to hardware
1721 : * @old_state: atomic state object with old state structures
1722 : *
1723 : * This is the default implementation for the
1724 : * &drm_mode_config_helper_funcs.atomic_commit_tail hook, for drivers
1725 : * that do not support runtime_pm or do not need the CRTC to be
1726 : * enabled to perform a commit. Otherwise, see
1727 : * drm_atomic_helper_commit_tail_rpm().
1728 : *
1729 : * Note that the default ordering of how the various stages are called is to
1730 : * match the legacy modeset helper library closest.
1731 : */
1732 0 : void drm_atomic_helper_commit_tail(struct drm_atomic_state *old_state)
1733 : {
1734 0 : struct drm_device *dev = old_state->dev;
1735 :
1736 0 : drm_atomic_helper_commit_modeset_disables(dev, old_state);
1737 :
1738 0 : drm_atomic_helper_commit_planes(dev, old_state, 0);
1739 :
1740 0 : drm_atomic_helper_commit_modeset_enables(dev, old_state);
1741 :
1742 0 : drm_atomic_helper_fake_vblank(old_state);
1743 :
1744 0 : drm_atomic_helper_commit_hw_done(old_state);
1745 :
1746 0 : drm_atomic_helper_wait_for_vblanks(dev, old_state);
1747 :
1748 0 : drm_atomic_helper_cleanup_planes(dev, old_state);
1749 0 : }
1750 : EXPORT_SYMBOL(drm_atomic_helper_commit_tail);
1751 :
1752 : /**
1753 : * drm_atomic_helper_commit_tail_rpm - commit atomic update to hardware
1754 : * @old_state: new modeset state to be committed
1755 : *
1756 : * This is an alternative implementation for the
1757 : * &drm_mode_config_helper_funcs.atomic_commit_tail hook, for drivers
1758 : * that support runtime_pm or need the CRTC to be enabled to perform a
1759 : * commit. Otherwise, one should use the default implementation
1760 : * drm_atomic_helper_commit_tail().
1761 : */
1762 0 : void drm_atomic_helper_commit_tail_rpm(struct drm_atomic_state *old_state)
1763 : {
1764 0 : struct drm_device *dev = old_state->dev;
1765 :
1766 0 : drm_atomic_helper_commit_modeset_disables(dev, old_state);
1767 :
1768 0 : drm_atomic_helper_commit_modeset_enables(dev, old_state);
1769 :
1770 0 : drm_atomic_helper_commit_planes(dev, old_state,
1771 : DRM_PLANE_COMMIT_ACTIVE_ONLY);
1772 :
1773 0 : drm_atomic_helper_fake_vblank(old_state);
1774 :
1775 0 : drm_atomic_helper_commit_hw_done(old_state);
1776 :
1777 0 : drm_atomic_helper_wait_for_vblanks(dev, old_state);
1778 :
1779 0 : drm_atomic_helper_cleanup_planes(dev, old_state);
1780 0 : }
1781 : EXPORT_SYMBOL(drm_atomic_helper_commit_tail_rpm);
1782 :
1783 0 : static void commit_tail(struct drm_atomic_state *old_state)
1784 : {
1785 0 : struct drm_device *dev = old_state->dev;
1786 : const struct drm_mode_config_helper_funcs *funcs;
1787 : struct drm_crtc_state *new_crtc_state;
1788 : struct drm_crtc *crtc;
1789 : ktime_t start;
1790 : s64 commit_time_ms;
1791 0 : unsigned int i, new_self_refresh_mask = 0;
1792 :
1793 0 : funcs = dev->mode_config.helper_private;
1794 :
1795 : /*
1796 : * We're measuring the _entire_ commit, so the time will vary depending
1797 : * on how many fences and objects are involved. For the purposes of self
1798 : * refresh, this is desirable since it'll give us an idea of how
1799 : * congested things are. This will inform our decision on how often we
1800 : * should enter self refresh after idle.
1801 : *
1802 : * These times will be averaged out in the self refresh helpers to avoid
1803 : * overreacting over one outlier frame
1804 : */
1805 0 : start = ktime_get();
1806 :
1807 0 : drm_atomic_helper_wait_for_fences(dev, old_state, false);
1808 :
1809 0 : drm_atomic_helper_wait_for_dependencies(old_state);
1810 :
1811 : /*
1812 : * We cannot safely access new_crtc_state after
1813 : * drm_atomic_helper_commit_hw_done() so figure out which crtc's have
1814 : * self-refresh active beforehand:
1815 : */
1816 0 : for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i)
1817 0 : if (new_crtc_state->self_refresh_active)
1818 0 : new_self_refresh_mask |= BIT(i);
1819 :
1820 0 : if (funcs && funcs->atomic_commit_tail)
1821 0 : funcs->atomic_commit_tail(old_state);
1822 : else
1823 0 : drm_atomic_helper_commit_tail(old_state);
1824 :
1825 0 : commit_time_ms = ktime_ms_delta(ktime_get(), start);
1826 0 : if (commit_time_ms > 0)
1827 0 : drm_self_refresh_helper_update_avg_times(old_state,
1828 : (unsigned long)commit_time_ms,
1829 : new_self_refresh_mask);
1830 :
1831 0 : drm_atomic_helper_commit_cleanup_done(old_state);
1832 :
1833 0 : drm_atomic_state_put(old_state);
1834 0 : }
1835 :
1836 0 : static void commit_work(struct work_struct *work)
1837 : {
1838 0 : struct drm_atomic_state *state = container_of(work,
1839 : struct drm_atomic_state,
1840 : commit_work);
1841 0 : commit_tail(state);
1842 0 : }
1843 :
1844 : /**
1845 : * drm_atomic_helper_async_check - check if state can be committed asynchronously
1846 : * @dev: DRM device
1847 : * @state: the driver state object
1848 : *
1849 : * This helper will check if it is possible to commit the state asynchronously.
1850 : * Async commits are not supposed to swap the states like normal sync commits
1851 : * but just do in-place changes on the current state.
1852 : *
1853 : * It will return 0 if the commit can happen in an asynchronous fashion or error
1854 : * if not. Note that error just mean it can't be committed asynchronously, if it
1855 : * fails the commit should be treated like a normal synchronous commit.
1856 : */
1857 0 : int drm_atomic_helper_async_check(struct drm_device *dev,
1858 : struct drm_atomic_state *state)
1859 : {
1860 : struct drm_crtc *crtc;
1861 : struct drm_crtc_state *crtc_state;
1862 0 : struct drm_plane *plane = NULL;
1863 0 : struct drm_plane_state *old_plane_state = NULL;
1864 0 : struct drm_plane_state *new_plane_state = NULL;
1865 : const struct drm_plane_helper_funcs *funcs;
1866 0 : int i, ret, n_planes = 0;
1867 :
1868 0 : for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
1869 0 : if (drm_atomic_crtc_needs_modeset(crtc_state))
1870 : return -EINVAL;
1871 : }
1872 :
1873 0 : for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i)
1874 0 : n_planes++;
1875 :
1876 : /* FIXME: we support only single plane updates for now */
1877 0 : if (n_planes != 1) {
1878 0 : drm_dbg_atomic(dev,
1879 : "only single plane async updates are supported\n");
1880 0 : return -EINVAL;
1881 : }
1882 :
1883 0 : if (!new_plane_state->crtc ||
1884 0 : old_plane_state->crtc != new_plane_state->crtc) {
1885 0 : drm_dbg_atomic(dev,
1886 : "[PLANE:%d:%s] async update cannot change CRTC\n",
1887 : plane->base.id, plane->name);
1888 0 : return -EINVAL;
1889 : }
1890 :
1891 0 : funcs = plane->helper_private;
1892 0 : if (!funcs->atomic_async_update) {
1893 0 : drm_dbg_atomic(dev,
1894 : "[PLANE:%d:%s] driver does not support async updates\n",
1895 : plane->base.id, plane->name);
1896 0 : return -EINVAL;
1897 : }
1898 :
1899 0 : if (new_plane_state->fence) {
1900 0 : drm_dbg_atomic(dev,
1901 : "[PLANE:%d:%s] missing fence for async update\n",
1902 : plane->base.id, plane->name);
1903 0 : return -EINVAL;
1904 : }
1905 :
1906 : /*
1907 : * Don't do an async update if there is an outstanding commit modifying
1908 : * the plane. This prevents our async update's changes from getting
1909 : * overridden by a previous synchronous update's state.
1910 : */
1911 0 : if (old_plane_state->commit &&
1912 0 : !try_wait_for_completion(&old_plane_state->commit->hw_done)) {
1913 0 : drm_dbg_atomic(dev,
1914 : "[PLANE:%d:%s] inflight previous commit preventing async commit\n",
1915 : plane->base.id, plane->name);
1916 0 : return -EBUSY;
1917 : }
1918 :
1919 0 : ret = funcs->atomic_async_check(plane, state);
1920 0 : if (ret != 0)
1921 0 : drm_dbg_atomic(dev,
1922 : "[PLANE:%d:%s] driver async check failed\n",
1923 : plane->base.id, plane->name);
1924 : return ret;
1925 : }
1926 : EXPORT_SYMBOL(drm_atomic_helper_async_check);
1927 :
1928 : /**
1929 : * drm_atomic_helper_async_commit - commit state asynchronously
1930 : * @dev: DRM device
1931 : * @state: the driver state object
1932 : *
1933 : * This function commits a state asynchronously, i.e., not vblank
1934 : * synchronized. It should be used on a state only when
1935 : * drm_atomic_async_check() succeeds. Async commits are not supposed to swap
1936 : * the states like normal sync commits, but just do in-place changes on the
1937 : * current state.
1938 : *
1939 : * TODO: Implement full swap instead of doing in-place changes.
1940 : */
1941 0 : void drm_atomic_helper_async_commit(struct drm_device *dev,
1942 : struct drm_atomic_state *state)
1943 : {
1944 : struct drm_plane *plane;
1945 : struct drm_plane_state *plane_state;
1946 : const struct drm_plane_helper_funcs *funcs;
1947 : int i;
1948 :
1949 0 : for_each_new_plane_in_state(state, plane, plane_state, i) {
1950 0 : struct drm_framebuffer *new_fb = plane_state->fb;
1951 0 : struct drm_framebuffer *old_fb = plane->state->fb;
1952 :
1953 0 : funcs = plane->helper_private;
1954 0 : funcs->atomic_async_update(plane, state);
1955 :
1956 : /*
1957 : * ->atomic_async_update() is supposed to update the
1958 : * plane->state in-place, make sure at least common
1959 : * properties have been properly updated.
1960 : */
1961 0 : WARN_ON_ONCE(plane->state->fb != new_fb);
1962 0 : WARN_ON_ONCE(plane->state->crtc_x != plane_state->crtc_x);
1963 0 : WARN_ON_ONCE(plane->state->crtc_y != plane_state->crtc_y);
1964 0 : WARN_ON_ONCE(plane->state->src_x != plane_state->src_x);
1965 0 : WARN_ON_ONCE(plane->state->src_y != plane_state->src_y);
1966 :
1967 : /*
1968 : * Make sure the FBs have been swapped so that cleanups in the
1969 : * new_state performs a cleanup in the old FB.
1970 : */
1971 0 : WARN_ON_ONCE(plane_state->fb != old_fb);
1972 : }
1973 0 : }
1974 : EXPORT_SYMBOL(drm_atomic_helper_async_commit);
1975 :
1976 : /**
1977 : * drm_atomic_helper_commit - commit validated state object
1978 : * @dev: DRM device
1979 : * @state: the driver state object
1980 : * @nonblock: whether nonblocking behavior is requested.
1981 : *
1982 : * This function commits a with drm_atomic_helper_check() pre-validated state
1983 : * object. This can still fail when e.g. the framebuffer reservation fails. This
1984 : * function implements nonblocking commits, using
1985 : * drm_atomic_helper_setup_commit() and related functions.
1986 : *
1987 : * Committing the actual hardware state is done through the
1988 : * &drm_mode_config_helper_funcs.atomic_commit_tail callback, or its default
1989 : * implementation drm_atomic_helper_commit_tail().
1990 : *
1991 : * RETURNS:
1992 : * Zero for success or -errno.
1993 : */
1994 0 : int drm_atomic_helper_commit(struct drm_device *dev,
1995 : struct drm_atomic_state *state,
1996 : bool nonblock)
1997 : {
1998 : int ret;
1999 :
2000 0 : if (state->async_update) {
2001 0 : ret = drm_atomic_helper_prepare_planes(dev, state);
2002 0 : if (ret)
2003 : return ret;
2004 :
2005 0 : drm_atomic_helper_async_commit(dev, state);
2006 0 : drm_atomic_helper_cleanup_planes(dev, state);
2007 :
2008 0 : return 0;
2009 : }
2010 :
2011 0 : ret = drm_atomic_helper_setup_commit(state, nonblock);
2012 0 : if (ret)
2013 : return ret;
2014 :
2015 0 : INIT_WORK(&state->commit_work, commit_work);
2016 :
2017 0 : ret = drm_atomic_helper_prepare_planes(dev, state);
2018 0 : if (ret)
2019 : return ret;
2020 :
2021 0 : if (!nonblock) {
2022 0 : ret = drm_atomic_helper_wait_for_fences(dev, state, true);
2023 0 : if (ret)
2024 : goto err;
2025 : }
2026 :
2027 : /*
2028 : * This is the point of no return - everything below never fails except
2029 : * when the hw goes bonghits. Which means we can commit the new state on
2030 : * the software side now.
2031 : */
2032 :
2033 0 : ret = drm_atomic_helper_swap_state(state, true);
2034 0 : if (ret)
2035 : goto err;
2036 :
2037 : /*
2038 : * Everything below can be run asynchronously without the need to grab
2039 : * any modeset locks at all under one condition: It must be guaranteed
2040 : * that the asynchronous work has either been cancelled (if the driver
2041 : * supports it, which at least requires that the framebuffers get
2042 : * cleaned up with drm_atomic_helper_cleanup_planes()) or completed
2043 : * before the new state gets committed on the software side with
2044 : * drm_atomic_helper_swap_state().
2045 : *
2046 : * This scheme allows new atomic state updates to be prepared and
2047 : * checked in parallel to the asynchronous completion of the previous
2048 : * update. Which is important since compositors need to figure out the
2049 : * composition of the next frame right after having submitted the
2050 : * current layout.
2051 : *
2052 : * NOTE: Commit work has multiple phases, first hardware commit, then
2053 : * cleanup. We want them to overlap, hence need system_unbound_wq to
2054 : * make sure work items don't artificially stall on each another.
2055 : */
2056 :
2057 0 : drm_atomic_state_get(state);
2058 0 : if (nonblock)
2059 0 : queue_work(system_unbound_wq, &state->commit_work);
2060 : else
2061 0 : commit_tail(state);
2062 :
2063 : return 0;
2064 :
2065 : err:
2066 0 : drm_atomic_helper_cleanup_planes(dev, state);
2067 0 : return ret;
2068 : }
2069 : EXPORT_SYMBOL(drm_atomic_helper_commit);
2070 :
2071 : /**
2072 : * DOC: implementing nonblocking commit
2073 : *
2074 : * Nonblocking atomic commits should use struct &drm_crtc_commit to sequence
2075 : * different operations against each another. Locks, especially struct
2076 : * &drm_modeset_lock, should not be held in worker threads or any other
2077 : * asynchronous context used to commit the hardware state.
2078 : *
2079 : * drm_atomic_helper_commit() implements the recommended sequence for
2080 : * nonblocking commits, using drm_atomic_helper_setup_commit() internally:
2081 : *
2082 : * 1. Run drm_atomic_helper_prepare_planes(). Since this can fail and we
2083 : * need to propagate out of memory/VRAM errors to userspace, it must be called
2084 : * synchronously.
2085 : *
2086 : * 2. Synchronize with any outstanding nonblocking commit worker threads which
2087 : * might be affected by the new state update. This is handled by
2088 : * drm_atomic_helper_setup_commit().
2089 : *
2090 : * Asynchronous workers need to have sufficient parallelism to be able to run
2091 : * different atomic commits on different CRTCs in parallel. The simplest way to
2092 : * achieve this is by running them on the &system_unbound_wq work queue. Note
2093 : * that drivers are not required to split up atomic commits and run an
2094 : * individual commit in parallel - userspace is supposed to do that if it cares.
2095 : * But it might be beneficial to do that for modesets, since those necessarily
2096 : * must be done as one global operation, and enabling or disabling a CRTC can
2097 : * take a long time. But even that is not required.
2098 : *
2099 : * IMPORTANT: A &drm_atomic_state update for multiple CRTCs is sequenced
2100 : * against all CRTCs therein. Therefore for atomic state updates which only flip
2101 : * planes the driver must not get the struct &drm_crtc_state of unrelated CRTCs
2102 : * in its atomic check code: This would prevent committing of atomic updates to
2103 : * multiple CRTCs in parallel. In general, adding additional state structures
2104 : * should be avoided as much as possible, because this reduces parallelism in
2105 : * (nonblocking) commits, both due to locking and due to commit sequencing
2106 : * requirements.
2107 : *
2108 : * 3. The software state is updated synchronously with
2109 : * drm_atomic_helper_swap_state(). Doing this under the protection of all modeset
2110 : * locks means concurrent callers never see inconsistent state. Note that commit
2111 : * workers do not hold any locks; their access is only coordinated through
2112 : * ordering. If workers would access state only through the pointers in the
2113 : * free-standing state objects (currently not the case for any driver) then even
2114 : * multiple pending commits could be in-flight at the same time.
2115 : *
2116 : * 4. Schedule a work item to do all subsequent steps, using the split-out
2117 : * commit helpers: a) pre-plane commit b) plane commit c) post-plane commit and
2118 : * then cleaning up the framebuffers after the old framebuffer is no longer
2119 : * being displayed. The scheduled work should synchronize against other workers
2120 : * using the &drm_crtc_commit infrastructure as needed. See
2121 : * drm_atomic_helper_setup_commit() for more details.
2122 : */
2123 :
2124 0 : static int stall_checks(struct drm_crtc *crtc, bool nonblock)
2125 : {
2126 0 : struct drm_crtc_commit *commit, *stall_commit = NULL;
2127 0 : bool completed = true;
2128 : int i;
2129 0 : long ret = 0;
2130 :
2131 0 : spin_lock(&crtc->commit_lock);
2132 0 : i = 0;
2133 0 : list_for_each_entry(commit, &crtc->commit_list, commit_entry) {
2134 0 : if (i == 0) {
2135 0 : completed = try_wait_for_completion(&commit->flip_done);
2136 : /*
2137 : * Userspace is not allowed to get ahead of the previous
2138 : * commit with nonblocking ones.
2139 : */
2140 0 : if (!completed && nonblock) {
2141 0 : spin_unlock(&crtc->commit_lock);
2142 0 : drm_dbg_atomic(crtc->dev,
2143 : "[CRTC:%d:%s] busy with a previous commit\n",
2144 : crtc->base.id, crtc->name);
2145 :
2146 0 : return -EBUSY;
2147 : }
2148 0 : } else if (i == 1) {
2149 0 : stall_commit = drm_crtc_commit_get(commit);
2150 0 : break;
2151 : }
2152 :
2153 0 : i++;
2154 : }
2155 0 : spin_unlock(&crtc->commit_lock);
2156 :
2157 0 : if (!stall_commit)
2158 : return 0;
2159 :
2160 : /* We don't want to let commits get ahead of cleanup work too much,
2161 : * stalling on 2nd previous commit means triple-buffer won't ever stall.
2162 : */
2163 0 : ret = wait_for_completion_interruptible_timeout(&stall_commit->cleanup_done,
2164 : 10*HZ);
2165 0 : if (ret == 0)
2166 0 : drm_err(crtc->dev, "[CRTC:%d:%s] cleanup_done timed out\n",
2167 : crtc->base.id, crtc->name);
2168 :
2169 0 : drm_crtc_commit_put(stall_commit);
2170 :
2171 0 : return ret < 0 ? ret : 0;
2172 : }
2173 :
2174 0 : static void release_crtc_commit(struct completion *completion)
2175 : {
2176 0 : struct drm_crtc_commit *commit = container_of(completion,
2177 : typeof(*commit),
2178 : flip_done);
2179 :
2180 0 : drm_crtc_commit_put(commit);
2181 0 : }
2182 :
2183 0 : static void init_commit(struct drm_crtc_commit *commit, struct drm_crtc *crtc)
2184 : {
2185 0 : init_completion(&commit->flip_done);
2186 0 : init_completion(&commit->hw_done);
2187 0 : init_completion(&commit->cleanup_done);
2188 0 : INIT_LIST_HEAD(&commit->commit_entry);
2189 0 : kref_init(&commit->ref);
2190 0 : commit->crtc = crtc;
2191 0 : }
2192 :
2193 : static struct drm_crtc_commit *
2194 0 : crtc_or_fake_commit(struct drm_atomic_state *state, struct drm_crtc *crtc)
2195 : {
2196 0 : if (crtc) {
2197 : struct drm_crtc_state *new_crtc_state;
2198 :
2199 0 : new_crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
2200 :
2201 0 : return new_crtc_state->commit;
2202 : }
2203 :
2204 0 : if (!state->fake_commit) {
2205 0 : state->fake_commit = kzalloc(sizeof(*state->fake_commit), GFP_KERNEL);
2206 0 : if (!state->fake_commit)
2207 : return NULL;
2208 :
2209 0 : init_commit(state->fake_commit, NULL);
2210 : }
2211 :
2212 0 : return state->fake_commit;
2213 : }
2214 :
2215 : /**
2216 : * drm_atomic_helper_setup_commit - setup possibly nonblocking commit
2217 : * @state: new modeset state to be committed
2218 : * @nonblock: whether nonblocking behavior is requested.
2219 : *
2220 : * This function prepares @state to be used by the atomic helper's support for
2221 : * nonblocking commits. Drivers using the nonblocking commit infrastructure
2222 : * should always call this function from their
2223 : * &drm_mode_config_funcs.atomic_commit hook.
2224 : *
2225 : * Drivers that need to extend the commit setup to private objects can use the
2226 : * &drm_mode_config_helper_funcs.atomic_commit_setup hook.
2227 : *
2228 : * To be able to use this support drivers need to use a few more helper
2229 : * functions. drm_atomic_helper_wait_for_dependencies() must be called before
2230 : * actually committing the hardware state, and for nonblocking commits this call
2231 : * must be placed in the async worker. See also drm_atomic_helper_swap_state()
2232 : * and its stall parameter, for when a driver's commit hooks look at the
2233 : * &drm_crtc.state, &drm_plane.state or &drm_connector.state pointer directly.
2234 : *
2235 : * Completion of the hardware commit step must be signalled using
2236 : * drm_atomic_helper_commit_hw_done(). After this step the driver is not allowed
2237 : * to read or change any permanent software or hardware modeset state. The only
2238 : * exception is state protected by other means than &drm_modeset_lock locks.
2239 : * Only the free standing @state with pointers to the old state structures can
2240 : * be inspected, e.g. to clean up old buffers using
2241 : * drm_atomic_helper_cleanup_planes().
2242 : *
2243 : * At the very end, before cleaning up @state drivers must call
2244 : * drm_atomic_helper_commit_cleanup_done().
2245 : *
2246 : * This is all implemented by in drm_atomic_helper_commit(), giving drivers a
2247 : * complete and easy-to-use default implementation of the atomic_commit() hook.
2248 : *
2249 : * The tracking of asynchronously executed and still pending commits is done
2250 : * using the core structure &drm_crtc_commit.
2251 : *
2252 : * By default there's no need to clean up resources allocated by this function
2253 : * explicitly: drm_atomic_state_default_clear() will take care of that
2254 : * automatically.
2255 : *
2256 : * Returns:
2257 : *
2258 : * 0 on success. -EBUSY when userspace schedules nonblocking commits too fast,
2259 : * -ENOMEM on allocation failures and -EINTR when a signal is pending.
2260 : */
2261 0 : int drm_atomic_helper_setup_commit(struct drm_atomic_state *state,
2262 : bool nonblock)
2263 : {
2264 : struct drm_crtc *crtc;
2265 : struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2266 : struct drm_connector *conn;
2267 : struct drm_connector_state *old_conn_state, *new_conn_state;
2268 : struct drm_plane *plane;
2269 : struct drm_plane_state *old_plane_state, *new_plane_state;
2270 : struct drm_crtc_commit *commit;
2271 : const struct drm_mode_config_helper_funcs *funcs;
2272 : int i, ret;
2273 :
2274 0 : funcs = state->dev->mode_config.helper_private;
2275 :
2276 0 : for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
2277 0 : commit = kzalloc(sizeof(*commit), GFP_KERNEL);
2278 0 : if (!commit)
2279 : return -ENOMEM;
2280 :
2281 0 : init_commit(commit, crtc);
2282 :
2283 0 : new_crtc_state->commit = commit;
2284 :
2285 0 : ret = stall_checks(crtc, nonblock);
2286 0 : if (ret)
2287 : return ret;
2288 :
2289 : /*
2290 : * Drivers only send out events when at least either current or
2291 : * new CRTC state is active. Complete right away if everything
2292 : * stays off.
2293 : */
2294 0 : if (!old_crtc_state->active && !new_crtc_state->active) {
2295 0 : complete_all(&commit->flip_done);
2296 0 : continue;
2297 : }
2298 :
2299 : /* Legacy cursor updates are fully unsynced. */
2300 0 : if (state->legacy_cursor_update) {
2301 0 : complete_all(&commit->flip_done);
2302 0 : continue;
2303 : }
2304 :
2305 0 : if (!new_crtc_state->event) {
2306 0 : commit->event = kzalloc(sizeof(*commit->event),
2307 : GFP_KERNEL);
2308 0 : if (!commit->event)
2309 : return -ENOMEM;
2310 :
2311 0 : new_crtc_state->event = commit->event;
2312 : }
2313 :
2314 0 : new_crtc_state->event->base.completion = &commit->flip_done;
2315 0 : new_crtc_state->event->base.completion_release = release_crtc_commit;
2316 0 : drm_crtc_commit_get(commit);
2317 :
2318 0 : commit->abort_completion = true;
2319 :
2320 0 : state->crtcs[i].commit = commit;
2321 : drm_crtc_commit_get(commit);
2322 : }
2323 :
2324 0 : for_each_oldnew_connector_in_state(state, conn, old_conn_state, new_conn_state, i) {
2325 : /*
2326 : * Userspace is not allowed to get ahead of the previous
2327 : * commit with nonblocking ones.
2328 : */
2329 0 : if (nonblock && old_conn_state->commit &&
2330 0 : !try_wait_for_completion(&old_conn_state->commit->flip_done)) {
2331 0 : drm_dbg_atomic(conn->dev,
2332 : "[CONNECTOR:%d:%s] busy with a previous commit\n",
2333 : conn->base.id, conn->name);
2334 :
2335 0 : return -EBUSY;
2336 : }
2337 :
2338 : /* Always track connectors explicitly for e.g. link retraining. */
2339 0 : commit = crtc_or_fake_commit(state, new_conn_state->crtc ?: old_conn_state->crtc);
2340 0 : if (!commit)
2341 : return -ENOMEM;
2342 :
2343 0 : new_conn_state->commit = drm_crtc_commit_get(commit);
2344 : }
2345 :
2346 0 : for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
2347 : /*
2348 : * Userspace is not allowed to get ahead of the previous
2349 : * commit with nonblocking ones.
2350 : */
2351 0 : if (nonblock && old_plane_state->commit &&
2352 0 : !try_wait_for_completion(&old_plane_state->commit->flip_done)) {
2353 0 : drm_dbg_atomic(plane->dev,
2354 : "[PLANE:%d:%s] busy with a previous commit\n",
2355 : plane->base.id, plane->name);
2356 :
2357 0 : return -EBUSY;
2358 : }
2359 :
2360 : /* Always track planes explicitly for async pageflip support. */
2361 0 : commit = crtc_or_fake_commit(state, new_plane_state->crtc ?: old_plane_state->crtc);
2362 0 : if (!commit)
2363 : return -ENOMEM;
2364 :
2365 0 : new_plane_state->commit = drm_crtc_commit_get(commit);
2366 : }
2367 :
2368 0 : if (funcs && funcs->atomic_commit_setup)
2369 0 : return funcs->atomic_commit_setup(state);
2370 :
2371 : return 0;
2372 : }
2373 : EXPORT_SYMBOL(drm_atomic_helper_setup_commit);
2374 :
2375 : /**
2376 : * drm_atomic_helper_wait_for_dependencies - wait for required preceeding commits
2377 : * @old_state: atomic state object with old state structures
2378 : *
2379 : * This function waits for all preceeding commits that touch the same CRTC as
2380 : * @old_state to both be committed to the hardware (as signalled by
2381 : * drm_atomic_helper_commit_hw_done()) and executed by the hardware (as signalled
2382 : * by calling drm_crtc_send_vblank_event() on the &drm_crtc_state.event).
2383 : *
2384 : * This is part of the atomic helper support for nonblocking commits, see
2385 : * drm_atomic_helper_setup_commit() for an overview.
2386 : */
2387 0 : void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state *old_state)
2388 : {
2389 : struct drm_crtc *crtc;
2390 : struct drm_crtc_state *old_crtc_state;
2391 : struct drm_plane *plane;
2392 : struct drm_plane_state *old_plane_state;
2393 : struct drm_connector *conn;
2394 : struct drm_connector_state *old_conn_state;
2395 : int i;
2396 : long ret;
2397 :
2398 0 : for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
2399 0 : ret = drm_crtc_commit_wait(old_crtc_state->commit);
2400 0 : if (ret)
2401 0 : drm_err(crtc->dev,
2402 : "[CRTC:%d:%s] commit wait timed out\n",
2403 : crtc->base.id, crtc->name);
2404 : }
2405 :
2406 0 : for_each_old_connector_in_state(old_state, conn, old_conn_state, i) {
2407 0 : ret = drm_crtc_commit_wait(old_conn_state->commit);
2408 0 : if (ret)
2409 0 : drm_err(conn->dev,
2410 : "[CONNECTOR:%d:%s] commit wait timed out\n",
2411 : conn->base.id, conn->name);
2412 : }
2413 :
2414 0 : for_each_old_plane_in_state(old_state, plane, old_plane_state, i) {
2415 0 : ret = drm_crtc_commit_wait(old_plane_state->commit);
2416 0 : if (ret)
2417 0 : drm_err(plane->dev,
2418 : "[PLANE:%d:%s] commit wait timed out\n",
2419 : plane->base.id, plane->name);
2420 : }
2421 0 : }
2422 : EXPORT_SYMBOL(drm_atomic_helper_wait_for_dependencies);
2423 :
2424 : /**
2425 : * drm_atomic_helper_fake_vblank - fake VBLANK events if needed
2426 : * @old_state: atomic state object with old state structures
2427 : *
2428 : * This function walks all CRTCs and fakes VBLANK events on those with
2429 : * &drm_crtc_state.no_vblank set to true and &drm_crtc_state.event != NULL.
2430 : * The primary use of this function is writeback connectors working in oneshot
2431 : * mode and faking VBLANK events. In this case they only fake the VBLANK event
2432 : * when a job is queued, and any change to the pipeline that does not touch the
2433 : * connector is leading to timeouts when calling
2434 : * drm_atomic_helper_wait_for_vblanks() or
2435 : * drm_atomic_helper_wait_for_flip_done(). In addition to writeback
2436 : * connectors, this function can also fake VBLANK events for CRTCs without
2437 : * VBLANK interrupt.
2438 : *
2439 : * This is part of the atomic helper support for nonblocking commits, see
2440 : * drm_atomic_helper_setup_commit() for an overview.
2441 : */
2442 0 : void drm_atomic_helper_fake_vblank(struct drm_atomic_state *old_state)
2443 : {
2444 : struct drm_crtc_state *new_crtc_state;
2445 : struct drm_crtc *crtc;
2446 : int i;
2447 :
2448 0 : for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
2449 : unsigned long flags;
2450 :
2451 0 : if (!new_crtc_state->no_vblank)
2452 0 : continue;
2453 :
2454 0 : spin_lock_irqsave(&old_state->dev->event_lock, flags);
2455 0 : if (new_crtc_state->event) {
2456 0 : drm_crtc_send_vblank_event(crtc,
2457 : new_crtc_state->event);
2458 0 : new_crtc_state->event = NULL;
2459 : }
2460 0 : spin_unlock_irqrestore(&old_state->dev->event_lock, flags);
2461 : }
2462 0 : }
2463 : EXPORT_SYMBOL(drm_atomic_helper_fake_vblank);
2464 :
2465 : /**
2466 : * drm_atomic_helper_commit_hw_done - setup possible nonblocking commit
2467 : * @old_state: atomic state object with old state structures
2468 : *
2469 : * This function is used to signal completion of the hardware commit step. After
2470 : * this step the driver is not allowed to read or change any permanent software
2471 : * or hardware modeset state. The only exception is state protected by other
2472 : * means than &drm_modeset_lock locks.
2473 : *
2474 : * Drivers should try to postpone any expensive or delayed cleanup work after
2475 : * this function is called.
2476 : *
2477 : * This is part of the atomic helper support for nonblocking commits, see
2478 : * drm_atomic_helper_setup_commit() for an overview.
2479 : */
2480 0 : void drm_atomic_helper_commit_hw_done(struct drm_atomic_state *old_state)
2481 : {
2482 : struct drm_crtc *crtc;
2483 : struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2484 : struct drm_crtc_commit *commit;
2485 : int i;
2486 :
2487 0 : for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2488 0 : commit = new_crtc_state->commit;
2489 0 : if (!commit)
2490 0 : continue;
2491 :
2492 : /*
2493 : * copy new_crtc_state->commit to old_crtc_state->commit,
2494 : * it's unsafe to touch new_crtc_state after hw_done,
2495 : * but we still need to do so in cleanup_done().
2496 : */
2497 0 : if (old_crtc_state->commit)
2498 0 : drm_crtc_commit_put(old_crtc_state->commit);
2499 :
2500 0 : old_crtc_state->commit = drm_crtc_commit_get(commit);
2501 :
2502 : /* backend must have consumed any event by now */
2503 0 : WARN_ON(new_crtc_state->event);
2504 0 : complete_all(&commit->hw_done);
2505 : }
2506 :
2507 0 : if (old_state->fake_commit) {
2508 0 : complete_all(&old_state->fake_commit->hw_done);
2509 0 : complete_all(&old_state->fake_commit->flip_done);
2510 : }
2511 0 : }
2512 : EXPORT_SYMBOL(drm_atomic_helper_commit_hw_done);
2513 :
2514 : /**
2515 : * drm_atomic_helper_commit_cleanup_done - signal completion of commit
2516 : * @old_state: atomic state object with old state structures
2517 : *
2518 : * This signals completion of the atomic update @old_state, including any
2519 : * cleanup work. If used, it must be called right before calling
2520 : * drm_atomic_state_put().
2521 : *
2522 : * This is part of the atomic helper support for nonblocking commits, see
2523 : * drm_atomic_helper_setup_commit() for an overview.
2524 : */
2525 0 : void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_state *old_state)
2526 : {
2527 : struct drm_crtc *crtc;
2528 : struct drm_crtc_state *old_crtc_state;
2529 : struct drm_crtc_commit *commit;
2530 : int i;
2531 :
2532 0 : for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
2533 0 : commit = old_crtc_state->commit;
2534 0 : if (WARN_ON(!commit))
2535 0 : continue;
2536 :
2537 0 : complete_all(&commit->cleanup_done);
2538 0 : WARN_ON(!try_wait_for_completion(&commit->hw_done));
2539 :
2540 0 : spin_lock(&crtc->commit_lock);
2541 0 : list_del(&commit->commit_entry);
2542 0 : spin_unlock(&crtc->commit_lock);
2543 : }
2544 :
2545 0 : if (old_state->fake_commit) {
2546 0 : complete_all(&old_state->fake_commit->cleanup_done);
2547 0 : WARN_ON(!try_wait_for_completion(&old_state->fake_commit->hw_done));
2548 : }
2549 0 : }
2550 : EXPORT_SYMBOL(drm_atomic_helper_commit_cleanup_done);
2551 :
2552 : /**
2553 : * drm_atomic_helper_prepare_planes - prepare plane resources before commit
2554 : * @dev: DRM device
2555 : * @state: atomic state object with new state structures
2556 : *
2557 : * This function prepares plane state, specifically framebuffers, for the new
2558 : * configuration, by calling &drm_plane_helper_funcs.prepare_fb. If any failure
2559 : * is encountered this function will call &drm_plane_helper_funcs.cleanup_fb on
2560 : * any already successfully prepared framebuffer.
2561 : *
2562 : * Returns:
2563 : * 0 on success, negative error code on failure.
2564 : */
2565 0 : int drm_atomic_helper_prepare_planes(struct drm_device *dev,
2566 : struct drm_atomic_state *state)
2567 : {
2568 : struct drm_connector *connector;
2569 : struct drm_connector_state *new_conn_state;
2570 : struct drm_plane *plane;
2571 : struct drm_plane_state *new_plane_state;
2572 : int ret, i, j;
2573 :
2574 0 : for_each_new_connector_in_state(state, connector, new_conn_state, i) {
2575 0 : if (!new_conn_state->writeback_job)
2576 0 : continue;
2577 :
2578 0 : ret = drm_writeback_prepare_job(new_conn_state->writeback_job);
2579 0 : if (ret < 0)
2580 : return ret;
2581 : }
2582 :
2583 0 : for_each_new_plane_in_state(state, plane, new_plane_state, i) {
2584 : const struct drm_plane_helper_funcs *funcs;
2585 :
2586 0 : funcs = plane->helper_private;
2587 :
2588 0 : if (funcs->prepare_fb) {
2589 0 : ret = funcs->prepare_fb(plane, new_plane_state);
2590 0 : if (ret)
2591 : goto fail_prepare_fb;
2592 : } else {
2593 0 : WARN_ON_ONCE(funcs->cleanup_fb);
2594 :
2595 0 : if (!drm_core_check_feature(dev, DRIVER_GEM))
2596 0 : continue;
2597 :
2598 0 : ret = drm_gem_plane_helper_prepare_fb(plane, new_plane_state);
2599 0 : if (ret)
2600 : goto fail_prepare_fb;
2601 : }
2602 : }
2603 :
2604 0 : for_each_new_plane_in_state(state, plane, new_plane_state, i) {
2605 0 : const struct drm_plane_helper_funcs *funcs = plane->helper_private;
2606 :
2607 0 : if (funcs->begin_fb_access) {
2608 0 : ret = funcs->begin_fb_access(plane, new_plane_state);
2609 0 : if (ret)
2610 : goto fail_begin_fb_access;
2611 : }
2612 : }
2613 :
2614 : return 0;
2615 :
2616 : fail_begin_fb_access:
2617 0 : for_each_new_plane_in_state(state, plane, new_plane_state, j) {
2618 0 : const struct drm_plane_helper_funcs *funcs = plane->helper_private;
2619 :
2620 0 : if (j >= i)
2621 0 : continue;
2622 :
2623 0 : if (funcs->end_fb_access)
2624 0 : funcs->end_fb_access(plane, new_plane_state);
2625 : }
2626 : i = j; /* set i to upper limit to cleanup all planes */
2627 : fail_prepare_fb:
2628 0 : for_each_new_plane_in_state(state, plane, new_plane_state, j) {
2629 : const struct drm_plane_helper_funcs *funcs;
2630 :
2631 0 : if (j >= i)
2632 0 : continue;
2633 :
2634 0 : funcs = plane->helper_private;
2635 :
2636 0 : if (funcs->cleanup_fb)
2637 0 : funcs->cleanup_fb(plane, new_plane_state);
2638 : }
2639 :
2640 : return ret;
2641 : }
2642 : EXPORT_SYMBOL(drm_atomic_helper_prepare_planes);
2643 :
2644 : static bool plane_crtc_active(const struct drm_plane_state *state)
2645 : {
2646 0 : return state->crtc && state->crtc->state->active;
2647 : }
2648 :
2649 : /**
2650 : * drm_atomic_helper_commit_planes - commit plane state
2651 : * @dev: DRM device
2652 : * @old_state: atomic state object with old state structures
2653 : * @flags: flags for committing plane state
2654 : *
2655 : * This function commits the new plane state using the plane and atomic helper
2656 : * functions for planes and CRTCs. It assumes that the atomic state has already
2657 : * been pushed into the relevant object state pointers, since this step can no
2658 : * longer fail.
2659 : *
2660 : * It still requires the global state object @old_state to know which planes and
2661 : * crtcs need to be updated though.
2662 : *
2663 : * Note that this function does all plane updates across all CRTCs in one step.
2664 : * If the hardware can't support this approach look at
2665 : * drm_atomic_helper_commit_planes_on_crtc() instead.
2666 : *
2667 : * Plane parameters can be updated by applications while the associated CRTC is
2668 : * disabled. The DRM/KMS core will store the parameters in the plane state,
2669 : * which will be available to the driver when the CRTC is turned on. As a result
2670 : * most drivers don't need to be immediately notified of plane updates for a
2671 : * disabled CRTC.
2672 : *
2673 : * Unless otherwise needed, drivers are advised to set the ACTIVE_ONLY flag in
2674 : * @flags in order not to receive plane update notifications related to a
2675 : * disabled CRTC. This avoids the need to manually ignore plane updates in
2676 : * driver code when the driver and/or hardware can't or just don't need to deal
2677 : * with updates on disabled CRTCs, for example when supporting runtime PM.
2678 : *
2679 : * Drivers may set the NO_DISABLE_AFTER_MODESET flag in @flags if the relevant
2680 : * display controllers require to disable a CRTC's planes when the CRTC is
2681 : * disabled. This function would skip the &drm_plane_helper_funcs.atomic_disable
2682 : * call for a plane if the CRTC of the old plane state needs a modesetting
2683 : * operation. Of course, the drivers need to disable the planes in their CRTC
2684 : * disable callbacks since no one else would do that.
2685 : *
2686 : * The drm_atomic_helper_commit() default implementation doesn't set the
2687 : * ACTIVE_ONLY flag to most closely match the behaviour of the legacy helpers.
2688 : * This should not be copied blindly by drivers.
2689 : */
2690 0 : void drm_atomic_helper_commit_planes(struct drm_device *dev,
2691 : struct drm_atomic_state *old_state,
2692 : uint32_t flags)
2693 : {
2694 : struct drm_crtc *crtc;
2695 : struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2696 : struct drm_plane *plane;
2697 : struct drm_plane_state *old_plane_state, *new_plane_state;
2698 : int i;
2699 0 : bool active_only = flags & DRM_PLANE_COMMIT_ACTIVE_ONLY;
2700 0 : bool no_disable = flags & DRM_PLANE_COMMIT_NO_DISABLE_AFTER_MODESET;
2701 :
2702 0 : for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2703 : const struct drm_crtc_helper_funcs *funcs;
2704 :
2705 0 : funcs = crtc->helper_private;
2706 :
2707 0 : if (!funcs || !funcs->atomic_begin)
2708 0 : continue;
2709 :
2710 0 : if (active_only && !new_crtc_state->active)
2711 0 : continue;
2712 :
2713 0 : funcs->atomic_begin(crtc, old_state);
2714 : }
2715 :
2716 0 : for_each_oldnew_plane_in_state(old_state, plane, old_plane_state, new_plane_state, i) {
2717 : const struct drm_plane_helper_funcs *funcs;
2718 : bool disabling;
2719 :
2720 0 : funcs = plane->helper_private;
2721 :
2722 0 : if (!funcs)
2723 0 : continue;
2724 :
2725 0 : disabling = drm_atomic_plane_disabling(old_plane_state,
2726 : new_plane_state);
2727 :
2728 0 : if (active_only) {
2729 : /*
2730 : * Skip planes related to inactive CRTCs. If the plane
2731 : * is enabled use the state of the current CRTC. If the
2732 : * plane is being disabled use the state of the old
2733 : * CRTC to avoid skipping planes being disabled on an
2734 : * active CRTC.
2735 : */
2736 0 : if (!disabling && !plane_crtc_active(new_plane_state))
2737 0 : continue;
2738 0 : if (disabling && !plane_crtc_active(old_plane_state))
2739 0 : continue;
2740 : }
2741 :
2742 : /*
2743 : * Special-case disabling the plane if drivers support it.
2744 : */
2745 0 : if (disabling && funcs->atomic_disable) {
2746 : struct drm_crtc_state *crtc_state;
2747 :
2748 0 : crtc_state = old_plane_state->crtc->state;
2749 :
2750 0 : if (drm_atomic_crtc_needs_modeset(crtc_state) &&
2751 : no_disable)
2752 0 : continue;
2753 :
2754 0 : funcs->atomic_disable(plane, old_state);
2755 0 : } else if (new_plane_state->crtc || disabling) {
2756 0 : funcs->atomic_update(plane, old_state);
2757 :
2758 0 : if (!disabling && funcs->atomic_enable) {
2759 0 : if (drm_atomic_plane_enabling(old_plane_state, new_plane_state))
2760 0 : funcs->atomic_enable(plane, old_state);
2761 : }
2762 : }
2763 : }
2764 :
2765 0 : for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2766 : const struct drm_crtc_helper_funcs *funcs;
2767 :
2768 0 : funcs = crtc->helper_private;
2769 :
2770 0 : if (!funcs || !funcs->atomic_flush)
2771 0 : continue;
2772 :
2773 0 : if (active_only && !new_crtc_state->active)
2774 0 : continue;
2775 :
2776 0 : funcs->atomic_flush(crtc, old_state);
2777 : }
2778 0 : }
2779 : EXPORT_SYMBOL(drm_atomic_helper_commit_planes);
2780 :
2781 : /**
2782 : * drm_atomic_helper_commit_planes_on_crtc - commit plane state for a CRTC
2783 : * @old_crtc_state: atomic state object with the old CRTC state
2784 : *
2785 : * This function commits the new plane state using the plane and atomic helper
2786 : * functions for planes on the specific CRTC. It assumes that the atomic state
2787 : * has already been pushed into the relevant object state pointers, since this
2788 : * step can no longer fail.
2789 : *
2790 : * This function is useful when plane updates should be done CRTC-by-CRTC
2791 : * instead of one global step like drm_atomic_helper_commit_planes() does.
2792 : *
2793 : * This function can only be savely used when planes are not allowed to move
2794 : * between different CRTCs because this function doesn't handle inter-CRTC
2795 : * dependencies. Callers need to ensure that either no such dependencies exist,
2796 : * resolve them through ordering of commit calls or through some other means.
2797 : */
2798 : void
2799 0 : drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_state)
2800 : {
2801 : const struct drm_crtc_helper_funcs *crtc_funcs;
2802 0 : struct drm_crtc *crtc = old_crtc_state->crtc;
2803 0 : struct drm_atomic_state *old_state = old_crtc_state->state;
2804 0 : struct drm_crtc_state *new_crtc_state =
2805 : drm_atomic_get_new_crtc_state(old_state, crtc);
2806 : struct drm_plane *plane;
2807 : unsigned int plane_mask;
2808 :
2809 0 : plane_mask = old_crtc_state->plane_mask;
2810 0 : plane_mask |= new_crtc_state->plane_mask;
2811 :
2812 0 : crtc_funcs = crtc->helper_private;
2813 0 : if (crtc_funcs && crtc_funcs->atomic_begin)
2814 0 : crtc_funcs->atomic_begin(crtc, old_state);
2815 :
2816 0 : drm_for_each_plane_mask(plane, crtc->dev, plane_mask) {
2817 0 : struct drm_plane_state *old_plane_state =
2818 : drm_atomic_get_old_plane_state(old_state, plane);
2819 0 : struct drm_plane_state *new_plane_state =
2820 : drm_atomic_get_new_plane_state(old_state, plane);
2821 : const struct drm_plane_helper_funcs *plane_funcs;
2822 : bool disabling;
2823 :
2824 0 : plane_funcs = plane->helper_private;
2825 :
2826 0 : if (!old_plane_state || !plane_funcs)
2827 0 : continue;
2828 :
2829 0 : WARN_ON(new_plane_state->crtc &&
2830 : new_plane_state->crtc != crtc);
2831 :
2832 0 : disabling = drm_atomic_plane_disabling(old_plane_state, new_plane_state);
2833 :
2834 0 : if (disabling && plane_funcs->atomic_disable) {
2835 0 : plane_funcs->atomic_disable(plane, old_state);
2836 0 : } else if (new_plane_state->crtc || disabling) {
2837 0 : plane_funcs->atomic_update(plane, old_state);
2838 :
2839 0 : if (!disabling && plane_funcs->atomic_enable) {
2840 0 : if (drm_atomic_plane_enabling(old_plane_state, new_plane_state))
2841 0 : plane_funcs->atomic_enable(plane, old_state);
2842 : }
2843 : }
2844 : }
2845 :
2846 0 : if (crtc_funcs && crtc_funcs->atomic_flush)
2847 0 : crtc_funcs->atomic_flush(crtc, old_state);
2848 0 : }
2849 : EXPORT_SYMBOL(drm_atomic_helper_commit_planes_on_crtc);
2850 :
2851 : /**
2852 : * drm_atomic_helper_disable_planes_on_crtc - helper to disable CRTC's planes
2853 : * @old_crtc_state: atomic state object with the old CRTC state
2854 : * @atomic: if set, synchronize with CRTC's atomic_begin/flush hooks
2855 : *
2856 : * Disables all planes associated with the given CRTC. This can be
2857 : * used for instance in the CRTC helper atomic_disable callback to disable
2858 : * all planes.
2859 : *
2860 : * If the atomic-parameter is set the function calls the CRTC's
2861 : * atomic_begin hook before and atomic_flush hook after disabling the
2862 : * planes.
2863 : *
2864 : * It is a bug to call this function without having implemented the
2865 : * &drm_plane_helper_funcs.atomic_disable plane hook.
2866 : */
2867 : void
2868 0 : drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc_state *old_crtc_state,
2869 : bool atomic)
2870 : {
2871 0 : struct drm_crtc *crtc = old_crtc_state->crtc;
2872 0 : const struct drm_crtc_helper_funcs *crtc_funcs =
2873 : crtc->helper_private;
2874 : struct drm_plane *plane;
2875 :
2876 0 : if (atomic && crtc_funcs && crtc_funcs->atomic_begin)
2877 0 : crtc_funcs->atomic_begin(crtc, NULL);
2878 :
2879 0 : drm_atomic_crtc_state_for_each_plane(plane, old_crtc_state) {
2880 0 : const struct drm_plane_helper_funcs *plane_funcs =
2881 : plane->helper_private;
2882 :
2883 0 : if (!plane_funcs)
2884 0 : continue;
2885 :
2886 0 : WARN_ON(!plane_funcs->atomic_disable);
2887 0 : if (plane_funcs->atomic_disable)
2888 0 : plane_funcs->atomic_disable(plane, NULL);
2889 : }
2890 :
2891 0 : if (atomic && crtc_funcs && crtc_funcs->atomic_flush)
2892 0 : crtc_funcs->atomic_flush(crtc, NULL);
2893 0 : }
2894 : EXPORT_SYMBOL(drm_atomic_helper_disable_planes_on_crtc);
2895 :
2896 : /**
2897 : * drm_atomic_helper_cleanup_planes - cleanup plane resources after commit
2898 : * @dev: DRM device
2899 : * @old_state: atomic state object with old state structures
2900 : *
2901 : * This function cleans up plane state, specifically framebuffers, from the old
2902 : * configuration. Hence the old configuration must be perserved in @old_state to
2903 : * be able to call this function.
2904 : *
2905 : * This function must also be called on the new state when the atomic update
2906 : * fails at any point after calling drm_atomic_helper_prepare_planes().
2907 : */
2908 0 : void drm_atomic_helper_cleanup_planes(struct drm_device *dev,
2909 : struct drm_atomic_state *old_state)
2910 : {
2911 : struct drm_plane *plane;
2912 : struct drm_plane_state *old_plane_state, *new_plane_state;
2913 : int i;
2914 :
2915 0 : for_each_oldnew_plane_in_state(old_state, plane, old_plane_state, new_plane_state, i) {
2916 0 : const struct drm_plane_helper_funcs *funcs = plane->helper_private;
2917 :
2918 0 : if (funcs->end_fb_access)
2919 0 : funcs->end_fb_access(plane, new_plane_state);
2920 : }
2921 :
2922 0 : for_each_oldnew_plane_in_state(old_state, plane, old_plane_state, new_plane_state, i) {
2923 : const struct drm_plane_helper_funcs *funcs;
2924 : struct drm_plane_state *plane_state;
2925 :
2926 : /*
2927 : * This might be called before swapping when commit is aborted,
2928 : * in which case we have to cleanup the new state.
2929 : */
2930 0 : if (old_plane_state == plane->state)
2931 : plane_state = new_plane_state;
2932 : else
2933 0 : plane_state = old_plane_state;
2934 :
2935 0 : funcs = plane->helper_private;
2936 :
2937 0 : if (funcs->cleanup_fb)
2938 0 : funcs->cleanup_fb(plane, plane_state);
2939 : }
2940 0 : }
2941 : EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes);
2942 :
2943 : /**
2944 : * drm_atomic_helper_swap_state - store atomic state into current sw state
2945 : * @state: atomic state
2946 : * @stall: stall for preceding commits
2947 : *
2948 : * This function stores the atomic state into the current state pointers in all
2949 : * driver objects. It should be called after all failing steps have been done
2950 : * and succeeded, but before the actual hardware state is committed.
2951 : *
2952 : * For cleanup and error recovery the current state for all changed objects will
2953 : * be swapped into @state.
2954 : *
2955 : * With that sequence it fits perfectly into the plane prepare/cleanup sequence:
2956 : *
2957 : * 1. Call drm_atomic_helper_prepare_planes() with the staged atomic state.
2958 : *
2959 : * 2. Do any other steps that might fail.
2960 : *
2961 : * 3. Put the staged state into the current state pointers with this function.
2962 : *
2963 : * 4. Actually commit the hardware state.
2964 : *
2965 : * 5. Call drm_atomic_helper_cleanup_planes() with @state, which since step 3
2966 : * contains the old state. Also do any other cleanup required with that state.
2967 : *
2968 : * @stall must be set when nonblocking commits for this driver directly access
2969 : * the &drm_plane.state, &drm_crtc.state or &drm_connector.state pointer. With
2970 : * the current atomic helpers this is almost always the case, since the helpers
2971 : * don't pass the right state structures to the callbacks.
2972 : *
2973 : * Returns:
2974 : *
2975 : * Returns 0 on success. Can return -ERESTARTSYS when @stall is true and the
2976 : * waiting for the previous commits has been interrupted.
2977 : */
2978 0 : int drm_atomic_helper_swap_state(struct drm_atomic_state *state,
2979 : bool stall)
2980 : {
2981 : int i, ret;
2982 : struct drm_connector *connector;
2983 : struct drm_connector_state *old_conn_state, *new_conn_state;
2984 : struct drm_crtc *crtc;
2985 : struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2986 : struct drm_plane *plane;
2987 : struct drm_plane_state *old_plane_state, *new_plane_state;
2988 : struct drm_crtc_commit *commit;
2989 : struct drm_private_obj *obj;
2990 : struct drm_private_state *old_obj_state, *new_obj_state;
2991 :
2992 0 : if (stall) {
2993 : /*
2994 : * We have to stall for hw_done here before
2995 : * drm_atomic_helper_wait_for_dependencies() because flip
2996 : * depth > 1 is not yet supported by all drivers. As long as
2997 : * obj->state is directly dereferenced anywhere in the drivers
2998 : * atomic_commit_tail function, then it's unsafe to swap state
2999 : * before drm_atomic_helper_commit_hw_done() is called.
3000 : */
3001 :
3002 0 : for_each_old_crtc_in_state(state, crtc, old_crtc_state, i) {
3003 0 : commit = old_crtc_state->commit;
3004 :
3005 0 : if (!commit)
3006 0 : continue;
3007 :
3008 0 : ret = wait_for_completion_interruptible(&commit->hw_done);
3009 0 : if (ret)
3010 : return ret;
3011 : }
3012 :
3013 0 : for_each_old_connector_in_state(state, connector, old_conn_state, i) {
3014 0 : commit = old_conn_state->commit;
3015 :
3016 0 : if (!commit)
3017 0 : continue;
3018 :
3019 0 : ret = wait_for_completion_interruptible(&commit->hw_done);
3020 0 : if (ret)
3021 : return ret;
3022 : }
3023 :
3024 0 : for_each_old_plane_in_state(state, plane, old_plane_state, i) {
3025 0 : commit = old_plane_state->commit;
3026 :
3027 0 : if (!commit)
3028 0 : continue;
3029 :
3030 0 : ret = wait_for_completion_interruptible(&commit->hw_done);
3031 0 : if (ret)
3032 : return ret;
3033 : }
3034 : }
3035 :
3036 0 : for_each_oldnew_connector_in_state(state, connector, old_conn_state, new_conn_state, i) {
3037 0 : WARN_ON(connector->state != old_conn_state);
3038 :
3039 0 : old_conn_state->state = state;
3040 0 : new_conn_state->state = NULL;
3041 :
3042 0 : state->connectors[i].state = old_conn_state;
3043 0 : connector->state = new_conn_state;
3044 : }
3045 :
3046 0 : for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
3047 0 : WARN_ON(crtc->state != old_crtc_state);
3048 :
3049 0 : old_crtc_state->state = state;
3050 0 : new_crtc_state->state = NULL;
3051 :
3052 0 : state->crtcs[i].state = old_crtc_state;
3053 0 : crtc->state = new_crtc_state;
3054 :
3055 0 : if (new_crtc_state->commit) {
3056 0 : spin_lock(&crtc->commit_lock);
3057 0 : list_add(&new_crtc_state->commit->commit_entry,
3058 : &crtc->commit_list);
3059 0 : spin_unlock(&crtc->commit_lock);
3060 :
3061 0 : new_crtc_state->commit->event = NULL;
3062 : }
3063 : }
3064 :
3065 0 : for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
3066 0 : WARN_ON(plane->state != old_plane_state);
3067 :
3068 0 : old_plane_state->state = state;
3069 0 : new_plane_state->state = NULL;
3070 :
3071 0 : state->planes[i].state = old_plane_state;
3072 0 : plane->state = new_plane_state;
3073 : }
3074 :
3075 0 : for_each_oldnew_private_obj_in_state(state, obj, old_obj_state, new_obj_state, i) {
3076 0 : WARN_ON(obj->state != old_obj_state);
3077 :
3078 0 : old_obj_state->state = state;
3079 0 : new_obj_state->state = NULL;
3080 :
3081 0 : state->private_objs[i].state = old_obj_state;
3082 0 : obj->state = new_obj_state;
3083 : }
3084 :
3085 : return 0;
3086 : }
3087 : EXPORT_SYMBOL(drm_atomic_helper_swap_state);
3088 :
3089 : /**
3090 : * drm_atomic_helper_update_plane - Helper for primary plane update using atomic
3091 : * @plane: plane object to update
3092 : * @crtc: owning CRTC of owning plane
3093 : * @fb: framebuffer to flip onto plane
3094 : * @crtc_x: x offset of primary plane on @crtc
3095 : * @crtc_y: y offset of primary plane on @crtc
3096 : * @crtc_w: width of primary plane rectangle on @crtc
3097 : * @crtc_h: height of primary plane rectangle on @crtc
3098 : * @src_x: x offset of @fb for panning
3099 : * @src_y: y offset of @fb for panning
3100 : * @src_w: width of source rectangle in @fb
3101 : * @src_h: height of source rectangle in @fb
3102 : * @ctx: lock acquire context
3103 : *
3104 : * Provides a default plane update handler using the atomic driver interface.
3105 : *
3106 : * RETURNS:
3107 : * Zero on success, error code on failure
3108 : */
3109 0 : int drm_atomic_helper_update_plane(struct drm_plane *plane,
3110 : struct drm_crtc *crtc,
3111 : struct drm_framebuffer *fb,
3112 : int crtc_x, int crtc_y,
3113 : unsigned int crtc_w, unsigned int crtc_h,
3114 : uint32_t src_x, uint32_t src_y,
3115 : uint32_t src_w, uint32_t src_h,
3116 : struct drm_modeset_acquire_ctx *ctx)
3117 : {
3118 : struct drm_atomic_state *state;
3119 : struct drm_plane_state *plane_state;
3120 0 : int ret = 0;
3121 :
3122 0 : state = drm_atomic_state_alloc(plane->dev);
3123 0 : if (!state)
3124 : return -ENOMEM;
3125 :
3126 0 : state->acquire_ctx = ctx;
3127 0 : plane_state = drm_atomic_get_plane_state(state, plane);
3128 0 : if (IS_ERR(plane_state)) {
3129 0 : ret = PTR_ERR(plane_state);
3130 0 : goto fail;
3131 : }
3132 :
3133 0 : ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
3134 0 : if (ret != 0)
3135 : goto fail;
3136 0 : drm_atomic_set_fb_for_plane(plane_state, fb);
3137 0 : plane_state->crtc_x = crtc_x;
3138 0 : plane_state->crtc_y = crtc_y;
3139 0 : plane_state->crtc_w = crtc_w;
3140 0 : plane_state->crtc_h = crtc_h;
3141 0 : plane_state->src_x = src_x;
3142 0 : plane_state->src_y = src_y;
3143 0 : plane_state->src_w = src_w;
3144 0 : plane_state->src_h = src_h;
3145 :
3146 0 : if (plane == crtc->cursor)
3147 0 : state->legacy_cursor_update = true;
3148 :
3149 0 : ret = drm_atomic_commit(state);
3150 : fail:
3151 0 : drm_atomic_state_put(state);
3152 0 : return ret;
3153 : }
3154 : EXPORT_SYMBOL(drm_atomic_helper_update_plane);
3155 :
3156 : /**
3157 : * drm_atomic_helper_disable_plane - Helper for primary plane disable using atomic
3158 : * @plane: plane to disable
3159 : * @ctx: lock acquire context
3160 : *
3161 : * Provides a default plane disable handler using the atomic driver interface.
3162 : *
3163 : * RETURNS:
3164 : * Zero on success, error code on failure
3165 : */
3166 0 : int drm_atomic_helper_disable_plane(struct drm_plane *plane,
3167 : struct drm_modeset_acquire_ctx *ctx)
3168 : {
3169 : struct drm_atomic_state *state;
3170 : struct drm_plane_state *plane_state;
3171 0 : int ret = 0;
3172 :
3173 0 : state = drm_atomic_state_alloc(plane->dev);
3174 0 : if (!state)
3175 : return -ENOMEM;
3176 :
3177 0 : state->acquire_ctx = ctx;
3178 0 : plane_state = drm_atomic_get_plane_state(state, plane);
3179 0 : if (IS_ERR(plane_state)) {
3180 0 : ret = PTR_ERR(plane_state);
3181 0 : goto fail;
3182 : }
3183 :
3184 0 : if (plane_state->crtc && plane_state->crtc->cursor == plane)
3185 0 : plane_state->state->legacy_cursor_update = true;
3186 :
3187 0 : ret = __drm_atomic_helper_disable_plane(plane, plane_state);
3188 0 : if (ret != 0)
3189 : goto fail;
3190 :
3191 0 : ret = drm_atomic_commit(state);
3192 : fail:
3193 0 : drm_atomic_state_put(state);
3194 0 : return ret;
3195 : }
3196 : EXPORT_SYMBOL(drm_atomic_helper_disable_plane);
3197 :
3198 : /**
3199 : * drm_atomic_helper_set_config - set a new config from userspace
3200 : * @set: mode set configuration
3201 : * @ctx: lock acquisition context
3202 : *
3203 : * Provides a default CRTC set_config handler using the atomic driver interface.
3204 : *
3205 : * NOTE: For backwards compatibility with old userspace this automatically
3206 : * resets the "link-status" property to GOOD, to force any link
3207 : * re-training. The SETCRTC ioctl does not define whether an update does
3208 : * need a full modeset or just a plane update, hence we're allowed to do
3209 : * that. See also drm_connector_set_link_status_property().
3210 : *
3211 : * Returns:
3212 : * Returns 0 on success, negative errno numbers on failure.
3213 : */
3214 0 : int drm_atomic_helper_set_config(struct drm_mode_set *set,
3215 : struct drm_modeset_acquire_ctx *ctx)
3216 : {
3217 : struct drm_atomic_state *state;
3218 0 : struct drm_crtc *crtc = set->crtc;
3219 0 : int ret = 0;
3220 :
3221 0 : state = drm_atomic_state_alloc(crtc->dev);
3222 0 : if (!state)
3223 : return -ENOMEM;
3224 :
3225 0 : state->acquire_ctx = ctx;
3226 0 : ret = __drm_atomic_helper_set_config(set, state);
3227 0 : if (ret != 0)
3228 : goto fail;
3229 :
3230 0 : ret = handle_conflicting_encoders(state, true);
3231 0 : if (ret)
3232 : goto fail;
3233 :
3234 0 : ret = drm_atomic_commit(state);
3235 :
3236 : fail:
3237 0 : drm_atomic_state_put(state);
3238 0 : return ret;
3239 : }
3240 : EXPORT_SYMBOL(drm_atomic_helper_set_config);
3241 :
3242 : /**
3243 : * drm_atomic_helper_disable_all - disable all currently active outputs
3244 : * @dev: DRM device
3245 : * @ctx: lock acquisition context
3246 : *
3247 : * Loops through all connectors, finding those that aren't turned off and then
3248 : * turns them off by setting their DPMS mode to OFF and deactivating the CRTC
3249 : * that they are connected to.
3250 : *
3251 : * This is used for example in suspend/resume to disable all currently active
3252 : * functions when suspending. If you just want to shut down everything at e.g.
3253 : * driver unload, look at drm_atomic_helper_shutdown().
3254 : *
3255 : * Note that if callers haven't already acquired all modeset locks this might
3256 : * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
3257 : *
3258 : * Returns:
3259 : * 0 on success or a negative error code on failure.
3260 : *
3261 : * See also:
3262 : * drm_atomic_helper_suspend(), drm_atomic_helper_resume() and
3263 : * drm_atomic_helper_shutdown().
3264 : */
3265 0 : int drm_atomic_helper_disable_all(struct drm_device *dev,
3266 : struct drm_modeset_acquire_ctx *ctx)
3267 : {
3268 : struct drm_atomic_state *state;
3269 : struct drm_connector_state *conn_state;
3270 : struct drm_connector *conn;
3271 : struct drm_plane_state *plane_state;
3272 : struct drm_plane *plane;
3273 : struct drm_crtc_state *crtc_state;
3274 : struct drm_crtc *crtc;
3275 : int ret, i;
3276 :
3277 0 : state = drm_atomic_state_alloc(dev);
3278 0 : if (!state)
3279 : return -ENOMEM;
3280 :
3281 0 : state->acquire_ctx = ctx;
3282 :
3283 0 : drm_for_each_crtc(crtc, dev) {
3284 0 : crtc_state = drm_atomic_get_crtc_state(state, crtc);
3285 0 : if (IS_ERR(crtc_state)) {
3286 0 : ret = PTR_ERR(crtc_state);
3287 0 : goto free;
3288 : }
3289 :
3290 0 : crtc_state->active = false;
3291 :
3292 0 : ret = drm_atomic_set_mode_prop_for_crtc(crtc_state, NULL);
3293 0 : if (ret < 0)
3294 : goto free;
3295 :
3296 0 : ret = drm_atomic_add_affected_planes(state, crtc);
3297 0 : if (ret < 0)
3298 : goto free;
3299 :
3300 0 : ret = drm_atomic_add_affected_connectors(state, crtc);
3301 0 : if (ret < 0)
3302 : goto free;
3303 : }
3304 :
3305 0 : for_each_new_connector_in_state(state, conn, conn_state, i) {
3306 0 : ret = drm_atomic_set_crtc_for_connector(conn_state, NULL);
3307 0 : if (ret < 0)
3308 : goto free;
3309 : }
3310 :
3311 0 : for_each_new_plane_in_state(state, plane, plane_state, i) {
3312 0 : ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
3313 0 : if (ret < 0)
3314 : goto free;
3315 :
3316 0 : drm_atomic_set_fb_for_plane(plane_state, NULL);
3317 : }
3318 :
3319 0 : ret = drm_atomic_commit(state);
3320 : free:
3321 0 : drm_atomic_state_put(state);
3322 0 : return ret;
3323 : }
3324 : EXPORT_SYMBOL(drm_atomic_helper_disable_all);
3325 :
3326 : /**
3327 : * drm_atomic_helper_shutdown - shutdown all CRTC
3328 : * @dev: DRM device
3329 : *
3330 : * This shuts down all CRTC, which is useful for driver unloading. Shutdown on
3331 : * suspend should instead be handled with drm_atomic_helper_suspend(), since
3332 : * that also takes a snapshot of the modeset state to be restored on resume.
3333 : *
3334 : * This is just a convenience wrapper around drm_atomic_helper_disable_all(),
3335 : * and it is the atomic version of drm_crtc_force_disable_all().
3336 : */
3337 0 : void drm_atomic_helper_shutdown(struct drm_device *dev)
3338 : {
3339 : struct drm_modeset_acquire_ctx ctx;
3340 : int ret;
3341 :
3342 0 : DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 0, ret);
3343 :
3344 0 : ret = drm_atomic_helper_disable_all(dev, &ctx);
3345 0 : if (ret)
3346 0 : drm_err(dev,
3347 : "Disabling all crtc's during unload failed with %i\n",
3348 : ret);
3349 :
3350 0 : DRM_MODESET_LOCK_ALL_END(dev, ctx, ret);
3351 0 : }
3352 : EXPORT_SYMBOL(drm_atomic_helper_shutdown);
3353 :
3354 : /**
3355 : * drm_atomic_helper_duplicate_state - duplicate an atomic state object
3356 : * @dev: DRM device
3357 : * @ctx: lock acquisition context
3358 : *
3359 : * Makes a copy of the current atomic state by looping over all objects and
3360 : * duplicating their respective states. This is used for example by suspend/
3361 : * resume support code to save the state prior to suspend such that it can
3362 : * be restored upon resume.
3363 : *
3364 : * Note that this treats atomic state as persistent between save and restore.
3365 : * Drivers must make sure that this is possible and won't result in confusion
3366 : * or erroneous behaviour.
3367 : *
3368 : * Note that if callers haven't already acquired all modeset locks this might
3369 : * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
3370 : *
3371 : * Returns:
3372 : * A pointer to the copy of the atomic state object on success or an
3373 : * ERR_PTR()-encoded error code on failure.
3374 : *
3375 : * See also:
3376 : * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
3377 : */
3378 : struct drm_atomic_state *
3379 0 : drm_atomic_helper_duplicate_state(struct drm_device *dev,
3380 : struct drm_modeset_acquire_ctx *ctx)
3381 : {
3382 : struct drm_atomic_state *state;
3383 : struct drm_connector *conn;
3384 : struct drm_connector_list_iter conn_iter;
3385 : struct drm_plane *plane;
3386 : struct drm_crtc *crtc;
3387 0 : int err = 0;
3388 :
3389 0 : state = drm_atomic_state_alloc(dev);
3390 0 : if (!state)
3391 : return ERR_PTR(-ENOMEM);
3392 :
3393 0 : state->acquire_ctx = ctx;
3394 0 : state->duplicated = true;
3395 :
3396 0 : drm_for_each_crtc(crtc, dev) {
3397 : struct drm_crtc_state *crtc_state;
3398 :
3399 0 : crtc_state = drm_atomic_get_crtc_state(state, crtc);
3400 0 : if (IS_ERR(crtc_state)) {
3401 0 : err = PTR_ERR(crtc_state);
3402 0 : goto free;
3403 : }
3404 : }
3405 :
3406 0 : drm_for_each_plane(plane, dev) {
3407 : struct drm_plane_state *plane_state;
3408 :
3409 0 : plane_state = drm_atomic_get_plane_state(state, plane);
3410 0 : if (IS_ERR(plane_state)) {
3411 0 : err = PTR_ERR(plane_state);
3412 0 : goto free;
3413 : }
3414 : }
3415 :
3416 0 : drm_connector_list_iter_begin(dev, &conn_iter);
3417 0 : drm_for_each_connector_iter(conn, &conn_iter) {
3418 : struct drm_connector_state *conn_state;
3419 :
3420 0 : conn_state = drm_atomic_get_connector_state(state, conn);
3421 0 : if (IS_ERR(conn_state)) {
3422 0 : err = PTR_ERR(conn_state);
3423 0 : drm_connector_list_iter_end(&conn_iter);
3424 0 : goto free;
3425 : }
3426 : }
3427 0 : drm_connector_list_iter_end(&conn_iter);
3428 :
3429 : /* clear the acquire context so that it isn't accidentally reused */
3430 0 : state->acquire_ctx = NULL;
3431 :
3432 : free:
3433 0 : if (err < 0) {
3434 0 : drm_atomic_state_put(state);
3435 0 : state = ERR_PTR(err);
3436 : }
3437 :
3438 : return state;
3439 : }
3440 : EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
3441 :
3442 : /**
3443 : * drm_atomic_helper_suspend - subsystem-level suspend helper
3444 : * @dev: DRM device
3445 : *
3446 : * Duplicates the current atomic state, disables all active outputs and then
3447 : * returns a pointer to the original atomic state to the caller. Drivers can
3448 : * pass this pointer to the drm_atomic_helper_resume() helper upon resume to
3449 : * restore the output configuration that was active at the time the system
3450 : * entered suspend.
3451 : *
3452 : * Note that it is potentially unsafe to use this. The atomic state object
3453 : * returned by this function is assumed to be persistent. Drivers must ensure
3454 : * that this holds true. Before calling this function, drivers must make sure
3455 : * to suspend fbdev emulation so that nothing can be using the device.
3456 : *
3457 : * Returns:
3458 : * A pointer to a copy of the state before suspend on success or an ERR_PTR()-
3459 : * encoded error code on failure. Drivers should store the returned atomic
3460 : * state object and pass it to the drm_atomic_helper_resume() helper upon
3461 : * resume.
3462 : *
3463 : * See also:
3464 : * drm_atomic_helper_duplicate_state(), drm_atomic_helper_disable_all(),
3465 : * drm_atomic_helper_resume(), drm_atomic_helper_commit_duplicated_state()
3466 : */
3467 0 : struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev)
3468 : {
3469 : struct drm_modeset_acquire_ctx ctx;
3470 : struct drm_atomic_state *state;
3471 : int err;
3472 :
3473 : /* This can never be returned, but it makes the compiler happy */
3474 0 : state = ERR_PTR(-EINVAL);
3475 :
3476 0 : DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 0, err);
3477 :
3478 0 : state = drm_atomic_helper_duplicate_state(dev, &ctx);
3479 0 : if (IS_ERR(state))
3480 : goto unlock;
3481 :
3482 0 : err = drm_atomic_helper_disable_all(dev, &ctx);
3483 0 : if (err < 0) {
3484 0 : drm_atomic_state_put(state);
3485 0 : state = ERR_PTR(err);
3486 0 : goto unlock;
3487 : }
3488 :
3489 : unlock:
3490 0 : DRM_MODESET_LOCK_ALL_END(dev, ctx, err);
3491 0 : if (err)
3492 0 : return ERR_PTR(err);
3493 :
3494 : return state;
3495 : }
3496 : EXPORT_SYMBOL(drm_atomic_helper_suspend);
3497 :
3498 : /**
3499 : * drm_atomic_helper_commit_duplicated_state - commit duplicated state
3500 : * @state: duplicated atomic state to commit
3501 : * @ctx: pointer to acquire_ctx to use for commit.
3502 : *
3503 : * The state returned by drm_atomic_helper_duplicate_state() and
3504 : * drm_atomic_helper_suspend() is partially invalid, and needs to
3505 : * be fixed up before commit.
3506 : *
3507 : * Returns:
3508 : * 0 on success or a negative error code on failure.
3509 : *
3510 : * See also:
3511 : * drm_atomic_helper_suspend()
3512 : */
3513 0 : int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state *state,
3514 : struct drm_modeset_acquire_ctx *ctx)
3515 : {
3516 : int i, ret;
3517 : struct drm_plane *plane;
3518 : struct drm_plane_state *new_plane_state;
3519 : struct drm_connector *connector;
3520 : struct drm_connector_state *new_conn_state;
3521 : struct drm_crtc *crtc;
3522 : struct drm_crtc_state *new_crtc_state;
3523 :
3524 0 : state->acquire_ctx = ctx;
3525 :
3526 0 : for_each_new_plane_in_state(state, plane, new_plane_state, i)
3527 0 : state->planes[i].old_state = plane->state;
3528 :
3529 0 : for_each_new_crtc_in_state(state, crtc, new_crtc_state, i)
3530 0 : state->crtcs[i].old_state = crtc->state;
3531 :
3532 0 : for_each_new_connector_in_state(state, connector, new_conn_state, i)
3533 0 : state->connectors[i].old_state = connector->state;
3534 :
3535 0 : ret = drm_atomic_commit(state);
3536 :
3537 0 : state->acquire_ctx = NULL;
3538 :
3539 0 : return ret;
3540 : }
3541 : EXPORT_SYMBOL(drm_atomic_helper_commit_duplicated_state);
3542 :
3543 : /**
3544 : * drm_atomic_helper_resume - subsystem-level resume helper
3545 : * @dev: DRM device
3546 : * @state: atomic state to resume to
3547 : *
3548 : * Calls drm_mode_config_reset() to synchronize hardware and software states,
3549 : * grabs all modeset locks and commits the atomic state object. This can be
3550 : * used in conjunction with the drm_atomic_helper_suspend() helper to
3551 : * implement suspend/resume for drivers that support atomic mode-setting.
3552 : *
3553 : * Returns:
3554 : * 0 on success or a negative error code on failure.
3555 : *
3556 : * See also:
3557 : * drm_atomic_helper_suspend()
3558 : */
3559 0 : int drm_atomic_helper_resume(struct drm_device *dev,
3560 : struct drm_atomic_state *state)
3561 : {
3562 : struct drm_modeset_acquire_ctx ctx;
3563 : int err;
3564 :
3565 0 : drm_mode_config_reset(dev);
3566 :
3567 0 : DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 0, err);
3568 :
3569 0 : err = drm_atomic_helper_commit_duplicated_state(state, &ctx);
3570 :
3571 0 : DRM_MODESET_LOCK_ALL_END(dev, ctx, err);
3572 0 : drm_atomic_state_put(state);
3573 :
3574 0 : return err;
3575 : }
3576 : EXPORT_SYMBOL(drm_atomic_helper_resume);
3577 :
3578 0 : static int page_flip_common(struct drm_atomic_state *state,
3579 : struct drm_crtc *crtc,
3580 : struct drm_framebuffer *fb,
3581 : struct drm_pending_vblank_event *event,
3582 : uint32_t flags)
3583 : {
3584 0 : struct drm_plane *plane = crtc->primary;
3585 : struct drm_plane_state *plane_state;
3586 : struct drm_crtc_state *crtc_state;
3587 0 : int ret = 0;
3588 :
3589 0 : crtc_state = drm_atomic_get_crtc_state(state, crtc);
3590 0 : if (IS_ERR(crtc_state))
3591 0 : return PTR_ERR(crtc_state);
3592 :
3593 0 : crtc_state->event = event;
3594 0 : crtc_state->async_flip = flags & DRM_MODE_PAGE_FLIP_ASYNC;
3595 :
3596 0 : plane_state = drm_atomic_get_plane_state(state, plane);
3597 0 : if (IS_ERR(plane_state))
3598 0 : return PTR_ERR(plane_state);
3599 :
3600 0 : ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
3601 0 : if (ret != 0)
3602 : return ret;
3603 0 : drm_atomic_set_fb_for_plane(plane_state, fb);
3604 :
3605 : /* Make sure we don't accidentally do a full modeset. */
3606 0 : state->allow_modeset = false;
3607 0 : if (!crtc_state->active) {
3608 0 : drm_dbg_atomic(crtc->dev,
3609 : "[CRTC:%d:%s] disabled, rejecting legacy flip\n",
3610 : crtc->base.id, crtc->name);
3611 0 : return -EINVAL;
3612 : }
3613 :
3614 : return ret;
3615 : }
3616 :
3617 : /**
3618 : * drm_atomic_helper_page_flip - execute a legacy page flip
3619 : * @crtc: DRM CRTC
3620 : * @fb: DRM framebuffer
3621 : * @event: optional DRM event to signal upon completion
3622 : * @flags: flip flags for non-vblank sync'ed updates
3623 : * @ctx: lock acquisition context
3624 : *
3625 : * Provides a default &drm_crtc_funcs.page_flip implementation
3626 : * using the atomic driver interface.
3627 : *
3628 : * Returns:
3629 : * Returns 0 on success, negative errno numbers on failure.
3630 : *
3631 : * See also:
3632 : * drm_atomic_helper_page_flip_target()
3633 : */
3634 0 : int drm_atomic_helper_page_flip(struct drm_crtc *crtc,
3635 : struct drm_framebuffer *fb,
3636 : struct drm_pending_vblank_event *event,
3637 : uint32_t flags,
3638 : struct drm_modeset_acquire_ctx *ctx)
3639 : {
3640 0 : struct drm_plane *plane = crtc->primary;
3641 : struct drm_atomic_state *state;
3642 0 : int ret = 0;
3643 :
3644 0 : state = drm_atomic_state_alloc(plane->dev);
3645 0 : if (!state)
3646 : return -ENOMEM;
3647 :
3648 0 : state->acquire_ctx = ctx;
3649 :
3650 0 : ret = page_flip_common(state, crtc, fb, event, flags);
3651 0 : if (ret != 0)
3652 : goto fail;
3653 :
3654 0 : ret = drm_atomic_nonblocking_commit(state);
3655 : fail:
3656 0 : drm_atomic_state_put(state);
3657 0 : return ret;
3658 : }
3659 : EXPORT_SYMBOL(drm_atomic_helper_page_flip);
3660 :
3661 : /**
3662 : * drm_atomic_helper_page_flip_target - do page flip on target vblank period.
3663 : * @crtc: DRM CRTC
3664 : * @fb: DRM framebuffer
3665 : * @event: optional DRM event to signal upon completion
3666 : * @flags: flip flags for non-vblank sync'ed updates
3667 : * @target: specifying the target vblank period when the flip to take effect
3668 : * @ctx: lock acquisition context
3669 : *
3670 : * Provides a default &drm_crtc_funcs.page_flip_target implementation.
3671 : * Similar to drm_atomic_helper_page_flip() with extra parameter to specify
3672 : * target vblank period to flip.
3673 : *
3674 : * Returns:
3675 : * Returns 0 on success, negative errno numbers on failure.
3676 : */
3677 0 : int drm_atomic_helper_page_flip_target(struct drm_crtc *crtc,
3678 : struct drm_framebuffer *fb,
3679 : struct drm_pending_vblank_event *event,
3680 : uint32_t flags,
3681 : uint32_t target,
3682 : struct drm_modeset_acquire_ctx *ctx)
3683 : {
3684 0 : struct drm_plane *plane = crtc->primary;
3685 : struct drm_atomic_state *state;
3686 : struct drm_crtc_state *crtc_state;
3687 0 : int ret = 0;
3688 :
3689 0 : state = drm_atomic_state_alloc(plane->dev);
3690 0 : if (!state)
3691 : return -ENOMEM;
3692 :
3693 0 : state->acquire_ctx = ctx;
3694 :
3695 0 : ret = page_flip_common(state, crtc, fb, event, flags);
3696 0 : if (ret != 0)
3697 : goto fail;
3698 :
3699 0 : crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
3700 0 : if (WARN_ON(!crtc_state)) {
3701 : ret = -EINVAL;
3702 : goto fail;
3703 : }
3704 0 : crtc_state->target_vblank = target;
3705 :
3706 0 : ret = drm_atomic_nonblocking_commit(state);
3707 : fail:
3708 0 : drm_atomic_state_put(state);
3709 0 : return ret;
3710 : }
3711 : EXPORT_SYMBOL(drm_atomic_helper_page_flip_target);
3712 :
3713 : /**
3714 : * drm_atomic_helper_bridge_propagate_bus_fmt() - Propagate output format to
3715 : * the input end of a bridge
3716 : * @bridge: bridge control structure
3717 : * @bridge_state: new bridge state
3718 : * @crtc_state: new CRTC state
3719 : * @conn_state: new connector state
3720 : * @output_fmt: tested output bus format
3721 : * @num_input_fmts: will contain the size of the returned array
3722 : *
3723 : * This helper is a pluggable implementation of the
3724 : * &drm_bridge_funcs.atomic_get_input_bus_fmts operation for bridges that don't
3725 : * modify the bus configuration between their input and their output. It
3726 : * returns an array of input formats with a single element set to @output_fmt.
3727 : *
3728 : * RETURNS:
3729 : * a valid format array of size @num_input_fmts, or NULL if the allocation
3730 : * failed
3731 : */
3732 : u32 *
3733 0 : drm_atomic_helper_bridge_propagate_bus_fmt(struct drm_bridge *bridge,
3734 : struct drm_bridge_state *bridge_state,
3735 : struct drm_crtc_state *crtc_state,
3736 : struct drm_connector_state *conn_state,
3737 : u32 output_fmt,
3738 : unsigned int *num_input_fmts)
3739 : {
3740 : u32 *input_fmts;
3741 :
3742 0 : input_fmts = kzalloc(sizeof(*input_fmts), GFP_KERNEL);
3743 0 : if (!input_fmts) {
3744 0 : *num_input_fmts = 0;
3745 0 : return NULL;
3746 : }
3747 :
3748 0 : *num_input_fmts = 1;
3749 0 : input_fmts[0] = output_fmt;
3750 0 : return input_fmts;
3751 : }
3752 : EXPORT_SYMBOL(drm_atomic_helper_bridge_propagate_bus_fmt);
|
