2 * Copyright (C) 2014 Red Hat
3 * Copyright (C) 2014 Intel Corp.
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:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
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.
24 * Rob Clark <robdclark@gmail.com>
25 * Daniel Vetter <daniel.vetter@ffwll.ch>
29 #include <drm/drm_atomic.h>
30 #include <drm/drm_plane_helper.h>
31 #include <drm/drm_crtc_helper.h>
32 #include <drm/drm_atomic_helper.h>
33 #include <linux/dma-fence.h>
35 #include "drm_crtc_internal.h"
40 * This helper library provides implementations of check and commit functions on
41 * top of the CRTC modeset helper callbacks and the plane helper callbacks. It
42 * also provides convenience implementations for the atomic state handling
43 * callbacks for drivers which don't need to subclass the drm core structures to
44 * add their own additional internal state.
46 * This library also provides default implementations for the check callback in
47 * drm_atomic_helper_check() and for the commit callback with
48 * drm_atomic_helper_commit(). But the individual stages and callbacks are
49 * exposed to allow drivers to mix and match and e.g. use the plane helpers only
50 * together with a driver private modeset implementation.
52 * This library also provides implementations for all the legacy driver
53 * interfaces on top of the atomic interface. See drm_atomic_helper_set_config(),
54 * drm_atomic_helper_disable_plane(), drm_atomic_helper_disable_plane() and the
55 * various functions to implement set_property callbacks. New drivers must not
56 * implement these functions themselves but must use the provided helpers.
58 * The atomic helper uses the same function table structures as all other
59 * modesetting helpers. See the documentation for &struct drm_crtc_helper_funcs,
60 * struct &drm_encoder_helper_funcs and &struct drm_connector_helper_funcs. It
61 * also shares the &struct drm_plane_helper_funcs function table with the plane
65 drm_atomic_helper_plane_changed(struct drm_atomic_state
*state
,
66 struct drm_plane_state
*old_plane_state
,
67 struct drm_plane_state
*plane_state
,
68 struct drm_plane
*plane
)
70 struct drm_crtc_state
*crtc_state
;
72 if (old_plane_state
->crtc
) {
73 crtc_state
= drm_atomic_get_new_crtc_state(state
,
74 old_plane_state
->crtc
);
76 if (WARN_ON(!crtc_state
))
79 crtc_state
->planes_changed
= true;
82 if (plane_state
->crtc
) {
83 crtc_state
= drm_atomic_get_new_crtc_state(state
, plane_state
->crtc
);
85 if (WARN_ON(!crtc_state
))
88 crtc_state
->planes_changed
= true;
92 static int handle_conflicting_encoders(struct drm_atomic_state
*state
,
93 bool disable_conflicting_encoders
)
95 struct drm_connector_state
*new_conn_state
;
96 struct drm_connector
*connector
;
97 struct drm_connector_list_iter conn_iter
;
98 struct drm_encoder
*encoder
;
99 unsigned encoder_mask
= 0;
103 * First loop, find all newly assigned encoders from the connectors
104 * part of the state. If the same encoder is assigned to multiple
105 * connectors bail out.
107 for_each_new_connector_in_state(state
, connector
, new_conn_state
, i
) {
108 const struct drm_connector_helper_funcs
*funcs
= connector
->helper_private
;
109 struct drm_encoder
*new_encoder
;
111 if (!new_conn_state
->crtc
)
114 if (funcs
->atomic_best_encoder
)
115 new_encoder
= funcs
->atomic_best_encoder(connector
, new_conn_state
);
116 else if (funcs
->best_encoder
)
117 new_encoder
= funcs
->best_encoder(connector
);
119 new_encoder
= drm_atomic_helper_best_encoder(connector
);
122 if (encoder_mask
& (1 << drm_encoder_index(new_encoder
))) {
123 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] on [CONNECTOR:%d:%s] already assigned\n",
124 new_encoder
->base
.id
, new_encoder
->name
,
125 connector
->base
.id
, connector
->name
);
130 encoder_mask
|= 1 << drm_encoder_index(new_encoder
);
138 * Second loop, iterate over all connectors not part of the state.
140 * If a conflicting encoder is found and disable_conflicting_encoders
141 * is not set, an error is returned. Userspace can provide a solution
142 * through the atomic ioctl.
144 * If the flag is set conflicting connectors are removed from the crtc
145 * and the crtc is disabled if no encoder is left. This preserves
146 * compatibility with the legacy set_config behavior.
148 drm_connector_list_iter_begin(state
->dev
, &conn_iter
);
149 drm_for_each_connector_iter(connector
, &conn_iter
) {
150 struct drm_crtc_state
*crtc_state
;
152 if (drm_atomic_get_new_connector_state(state
, connector
))
155 encoder
= connector
->state
->best_encoder
;
156 if (!encoder
|| !(encoder_mask
& (1 << drm_encoder_index(encoder
))))
159 if (!disable_conflicting_encoders
) {
160 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d:%s] by [CONNECTOR:%d:%s]\n",
161 encoder
->base
.id
, encoder
->name
,
162 connector
->state
->crtc
->base
.id
,
163 connector
->state
->crtc
->name
,
164 connector
->base
.id
, connector
->name
);
169 new_conn_state
= drm_atomic_get_connector_state(state
, connector
);
170 if (IS_ERR(new_conn_state
)) {
171 ret
= PTR_ERR(new_conn_state
);
175 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d:%s], disabling [CONNECTOR:%d:%s]\n",
176 encoder
->base
.id
, encoder
->name
,
177 new_conn_state
->crtc
->base
.id
, new_conn_state
->crtc
->name
,
178 connector
->base
.id
, connector
->name
);
180 crtc_state
= drm_atomic_get_new_crtc_state(state
, new_conn_state
->crtc
);
182 ret
= drm_atomic_set_crtc_for_connector(new_conn_state
, NULL
);
186 if (!crtc_state
->connector_mask
) {
187 ret
= drm_atomic_set_mode_prop_for_crtc(crtc_state
,
192 crtc_state
->active
= false;
196 drm_connector_list_iter_end(&conn_iter
);
202 set_best_encoder(struct drm_atomic_state
*state
,
203 struct drm_connector_state
*conn_state
,
204 struct drm_encoder
*encoder
)
206 struct drm_crtc_state
*crtc_state
;
207 struct drm_crtc
*crtc
;
209 if (conn_state
->best_encoder
) {
210 /* Unset the encoder_mask in the old crtc state. */
211 crtc
= conn_state
->connector
->state
->crtc
;
213 /* A NULL crtc is an error here because we should have
214 * duplicated a NULL best_encoder when crtc was NULL.
215 * As an exception restoring duplicated atomic state
216 * during resume is allowed, so don't warn when
217 * best_encoder is equal to encoder we intend to set.
219 WARN_ON(!crtc
&& encoder
!= conn_state
->best_encoder
);
221 crtc_state
= drm_atomic_get_new_crtc_state(state
, crtc
);
223 crtc_state
->encoder_mask
&=
224 ~(1 << drm_encoder_index(conn_state
->best_encoder
));
229 crtc
= conn_state
->crtc
;
232 crtc_state
= drm_atomic_get_new_crtc_state(state
, crtc
);
234 crtc_state
->encoder_mask
|=
235 1 << drm_encoder_index(encoder
);
239 conn_state
->best_encoder
= encoder
;
243 steal_encoder(struct drm_atomic_state
*state
,
244 struct drm_encoder
*encoder
)
246 struct drm_crtc_state
*crtc_state
;
247 struct drm_connector
*connector
;
248 struct drm_connector_state
*old_connector_state
, *new_connector_state
;
251 for_each_oldnew_connector_in_state(state
, connector
, old_connector_state
, new_connector_state
, i
) {
252 struct drm_crtc
*encoder_crtc
;
254 if (new_connector_state
->best_encoder
!= encoder
)
257 encoder_crtc
= old_connector_state
->crtc
;
259 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d:%s], stealing it\n",
260 encoder
->base
.id
, encoder
->name
,
261 encoder_crtc
->base
.id
, encoder_crtc
->name
);
263 set_best_encoder(state
, new_connector_state
, NULL
);
265 crtc_state
= drm_atomic_get_new_crtc_state(state
, encoder_crtc
);
266 crtc_state
->connectors_changed
= true;
273 update_connector_routing(struct drm_atomic_state
*state
,
274 struct drm_connector
*connector
,
275 struct drm_connector_state
*old_connector_state
,
276 struct drm_connector_state
*new_connector_state
)
278 const struct drm_connector_helper_funcs
*funcs
;
279 struct drm_encoder
*new_encoder
;
280 struct drm_crtc_state
*crtc_state
;
282 DRM_DEBUG_ATOMIC("Updating routing for [CONNECTOR:%d:%s]\n",
286 if (old_connector_state
->crtc
!= new_connector_state
->crtc
) {
287 if (old_connector_state
->crtc
) {
288 crtc_state
= drm_atomic_get_new_crtc_state(state
, old_connector_state
->crtc
);
289 crtc_state
->connectors_changed
= true;
292 if (new_connector_state
->crtc
) {
293 crtc_state
= drm_atomic_get_new_crtc_state(state
, new_connector_state
->crtc
);
294 crtc_state
->connectors_changed
= true;
298 if (!new_connector_state
->crtc
) {
299 DRM_DEBUG_ATOMIC("Disabling [CONNECTOR:%d:%s]\n",
303 set_best_encoder(state
, new_connector_state
, NULL
);
308 funcs
= connector
->helper_private
;
310 if (funcs
->atomic_best_encoder
)
311 new_encoder
= funcs
->atomic_best_encoder(connector
,
312 new_connector_state
);
313 else if (funcs
->best_encoder
)
314 new_encoder
= funcs
->best_encoder(connector
);
316 new_encoder
= drm_atomic_helper_best_encoder(connector
);
319 DRM_DEBUG_ATOMIC("No suitable encoder found for [CONNECTOR:%d:%s]\n",
325 if (!drm_encoder_crtc_ok(new_encoder
, new_connector_state
->crtc
)) {
326 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] incompatible with [CRTC:%d:%s]\n",
327 new_encoder
->base
.id
,
329 new_connector_state
->crtc
->base
.id
,
330 new_connector_state
->crtc
->name
);
334 if (new_encoder
== new_connector_state
->best_encoder
) {
335 set_best_encoder(state
, new_connector_state
, new_encoder
);
337 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] keeps [ENCODER:%d:%s], now on [CRTC:%d:%s]\n",
340 new_encoder
->base
.id
,
342 new_connector_state
->crtc
->base
.id
,
343 new_connector_state
->crtc
->name
);
348 steal_encoder(state
, new_encoder
);
350 set_best_encoder(state
, new_connector_state
, new_encoder
);
352 crtc_state
= drm_atomic_get_new_crtc_state(state
, new_connector_state
->crtc
);
353 crtc_state
->connectors_changed
= true;
355 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] using [ENCODER:%d:%s] on [CRTC:%d:%s]\n",
358 new_encoder
->base
.id
,
360 new_connector_state
->crtc
->base
.id
,
361 new_connector_state
->crtc
->name
);
367 mode_fixup(struct drm_atomic_state
*state
)
369 struct drm_crtc
*crtc
;
370 struct drm_crtc_state
*new_crtc_state
;
371 struct drm_connector
*connector
;
372 struct drm_connector_state
*new_conn_state
;
376 for_each_new_crtc_in_state(state
, crtc
, new_crtc_state
, i
) {
377 if (!new_crtc_state
->mode_changed
&&
378 !new_crtc_state
->connectors_changed
)
381 drm_mode_copy(&new_crtc_state
->adjusted_mode
, &new_crtc_state
->mode
);
384 for_each_new_connector_in_state(state
, connector
, new_conn_state
, i
) {
385 const struct drm_encoder_helper_funcs
*funcs
;
386 struct drm_encoder
*encoder
;
388 WARN_ON(!!new_conn_state
->best_encoder
!= !!new_conn_state
->crtc
);
390 if (!new_conn_state
->crtc
|| !new_conn_state
->best_encoder
)
394 drm_atomic_get_new_crtc_state(state
, new_conn_state
->crtc
);
397 * Each encoder has at most one connector (since we always steal
398 * it away), so we won't call ->mode_fixup twice.
400 encoder
= new_conn_state
->best_encoder
;
401 funcs
= encoder
->helper_private
;
403 ret
= drm_bridge_mode_fixup(encoder
->bridge
, &new_crtc_state
->mode
,
404 &new_crtc_state
->adjusted_mode
);
406 DRM_DEBUG_ATOMIC("Bridge fixup failed\n");
410 if (funcs
&& funcs
->atomic_check
) {
411 ret
= funcs
->atomic_check(encoder
, new_crtc_state
,
414 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] check failed\n",
415 encoder
->base
.id
, encoder
->name
);
418 } else if (funcs
&& funcs
->mode_fixup
) {
419 ret
= funcs
->mode_fixup(encoder
, &new_crtc_state
->mode
,
420 &new_crtc_state
->adjusted_mode
);
422 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] fixup failed\n",
423 encoder
->base
.id
, encoder
->name
);
429 for_each_new_crtc_in_state(state
, crtc
, new_crtc_state
, i
) {
430 const struct drm_crtc_helper_funcs
*funcs
;
432 if (!new_crtc_state
->enable
)
435 if (!new_crtc_state
->mode_changed
&&
436 !new_crtc_state
->connectors_changed
)
439 funcs
= crtc
->helper_private
;
440 if (!funcs
->mode_fixup
)
443 ret
= funcs
->mode_fixup(crtc
, &new_crtc_state
->mode
,
444 &new_crtc_state
->adjusted_mode
);
446 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] fixup failed\n",
447 crtc
->base
.id
, crtc
->name
);
456 * drm_atomic_helper_check_modeset - validate state object for modeset changes
458 * @state: the driver state object
460 * Check the state object to see if the requested state is physically possible.
461 * This does all the crtc and connector related computations for an atomic
462 * update and adds any additional connectors needed for full modesets. It calls
463 * the various per-object callbacks in the follow order:
465 * 1. &drm_connector_helper_funcs.atomic_best_encoder for determining the new encoder.
466 * 2. &drm_connector_helper_funcs.atomic_check to validate the connector state.
467 * 3. If it's determined a modeset is needed then all connectors on the affected crtc
468 * crtc are added and &drm_connector_helper_funcs.atomic_check is run on them.
469 * 4. &drm_bridge_funcs.mode_fixup is called on all encoder bridges.
470 * 5. &drm_encoder_helper_funcs.atomic_check is called to validate any encoder state.
471 * This function is only called when the encoder will be part of a configured crtc,
472 * it must not be used for implementing connector property validation.
473 * If this function is NULL, &drm_atomic_encoder_helper_funcs.mode_fixup is called
475 * 6. &drm_crtc_helper_funcs.mode_fixup is called last, to fix up the mode with crtc constraints.
477 * &drm_crtc_state.mode_changed is set when the input mode is changed.
478 * &drm_crtc_state.connectors_changed is set when a connector is added or
479 * removed from the crtc. &drm_crtc_state.active_changed is set when
480 * &drm_crtc_state.active changes, which is used for DPMS.
481 * See also: drm_atomic_crtc_needs_modeset()
485 * Drivers which set &drm_crtc_state.mode_changed (e.g. in their
486 * &drm_plane_helper_funcs.atomic_check hooks if a plane update can't be done
487 * without a full modeset) _must_ call this function afterwards after that
488 * change. It is permitted to call this function multiple times for the same
489 * update, e.g. when the &drm_crtc_helper_funcs.atomic_check functions depend
490 * upon the adjusted dotclock for fifo space allocation and watermark
494 * Zero for success or -errno
497 drm_atomic_helper_check_modeset(struct drm_device
*dev
,
498 struct drm_atomic_state
*state
)
500 struct drm_crtc
*crtc
;
501 struct drm_crtc_state
*old_crtc_state
, *new_crtc_state
;
502 struct drm_connector
*connector
;
503 struct drm_connector_state
*old_connector_state
, *new_connector_state
;
505 unsigned connectors_mask
= 0;
507 for_each_oldnew_crtc_in_state(state
, crtc
, old_crtc_state
, new_crtc_state
, i
) {
508 bool has_connectors
=
509 !!new_crtc_state
->connector_mask
;
511 WARN_ON(!drm_modeset_is_locked(&crtc
->mutex
));
513 if (!drm_mode_equal(&old_crtc_state
->mode
, &new_crtc_state
->mode
)) {
514 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] mode changed\n",
515 crtc
->base
.id
, crtc
->name
);
516 new_crtc_state
->mode_changed
= true;
519 if (old_crtc_state
->enable
!= new_crtc_state
->enable
) {
520 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enable changed\n",
521 crtc
->base
.id
, crtc
->name
);
524 * For clarity this assignment is done here, but
525 * enable == 0 is only true when there are no
526 * connectors and a NULL mode.
528 * The other way around is true as well. enable != 0
529 * iff connectors are attached and a mode is set.
531 new_crtc_state
->mode_changed
= true;
532 new_crtc_state
->connectors_changed
= true;
535 if (old_crtc_state
->active
!= new_crtc_state
->active
) {
536 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active changed\n",
537 crtc
->base
.id
, crtc
->name
);
538 new_crtc_state
->active_changed
= true;
541 if (new_crtc_state
->enable
!= has_connectors
) {
542 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled/connectors mismatch\n",
543 crtc
->base
.id
, crtc
->name
);
549 ret
= handle_conflicting_encoders(state
, false);
553 for_each_oldnew_connector_in_state(state
, connector
, old_connector_state
, new_connector_state
, i
) {
554 const struct drm_connector_helper_funcs
*funcs
= connector
->helper_private
;
556 WARN_ON(!drm_modeset_is_locked(&dev
->mode_config
.connection_mutex
));
559 * This only sets crtc->connectors_changed for routing changes,
560 * drivers must set crtc->connectors_changed themselves when
561 * connector properties need to be updated.
563 ret
= update_connector_routing(state
, connector
,
565 new_connector_state
);
568 if (old_connector_state
->crtc
) {
569 new_crtc_state
= drm_atomic_get_new_crtc_state(state
,
570 old_connector_state
->crtc
);
571 if (old_connector_state
->link_status
!=
572 new_connector_state
->link_status
)
573 new_crtc_state
->connectors_changed
= true;
576 if (funcs
->atomic_check
)
577 ret
= funcs
->atomic_check(connector
, new_connector_state
);
581 connectors_mask
+= BIT(i
);
585 * After all the routing has been prepared we need to add in any
586 * connector which is itself unchanged, but who's crtc changes it's
587 * configuration. This must be done before calling mode_fixup in case a
588 * crtc only changed its mode but has the same set of connectors.
590 for_each_oldnew_crtc_in_state(state
, crtc
, old_crtc_state
, new_crtc_state
, i
) {
591 if (!drm_atomic_crtc_needs_modeset(new_crtc_state
))
594 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] needs all connectors, enable: %c, active: %c\n",
595 crtc
->base
.id
, crtc
->name
,
596 new_crtc_state
->enable
? 'y' : 'n',
597 new_crtc_state
->active
? 'y' : 'n');
599 ret
= drm_atomic_add_affected_connectors(state
, crtc
);
603 ret
= drm_atomic_add_affected_planes(state
, crtc
);
609 * Iterate over all connectors again, to make sure atomic_check()
610 * has been called on them when a modeset is forced.
612 for_each_oldnew_connector_in_state(state
, connector
, old_connector_state
, new_connector_state
, i
) {
613 const struct drm_connector_helper_funcs
*funcs
= connector
->helper_private
;
615 if (connectors_mask
& BIT(i
))
618 if (funcs
->atomic_check
)
619 ret
= funcs
->atomic_check(connector
, new_connector_state
);
624 return mode_fixup(state
);
626 EXPORT_SYMBOL(drm_atomic_helper_check_modeset
);
629 * drm_atomic_helper_check_planes - validate state object for planes changes
631 * @state: the driver state object
633 * Check the state object to see if the requested state is physically possible.
634 * This does all the plane update related checks using by calling into the
635 * &drm_crtc_helper_funcs.atomic_check and &drm_plane_helper_funcs.atomic_check
636 * hooks provided by the driver.
638 * It also sets &drm_crtc_state.planes_changed to indicate that a crtc has
642 * Zero for success or -errno
645 drm_atomic_helper_check_planes(struct drm_device
*dev
,
646 struct drm_atomic_state
*state
)
648 struct drm_crtc
*crtc
;
649 struct drm_crtc_state
*new_crtc_state
;
650 struct drm_plane
*plane
;
651 struct drm_plane_state
*new_plane_state
, *old_plane_state
;
654 for_each_oldnew_plane_in_state(state
, plane
, old_plane_state
, new_plane_state
, i
) {
655 const struct drm_plane_helper_funcs
*funcs
;
657 WARN_ON(!drm_modeset_is_locked(&plane
->mutex
));
659 funcs
= plane
->helper_private
;
661 drm_atomic_helper_plane_changed(state
, old_plane_state
, new_plane_state
, plane
);
663 if (!funcs
|| !funcs
->atomic_check
)
666 ret
= funcs
->atomic_check(plane
, new_plane_state
);
668 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic driver check failed\n",
669 plane
->base
.id
, plane
->name
);
674 for_each_new_crtc_in_state(state
, crtc
, new_crtc_state
, i
) {
675 const struct drm_crtc_helper_funcs
*funcs
;
677 funcs
= crtc
->helper_private
;
679 if (!funcs
|| !funcs
->atomic_check
)
682 ret
= funcs
->atomic_check(crtc
, new_crtc_state
);
684 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic driver check failed\n",
685 crtc
->base
.id
, crtc
->name
);
692 EXPORT_SYMBOL(drm_atomic_helper_check_planes
);
695 * drm_atomic_helper_check - validate state object
697 * @state: the driver state object
699 * Check the state object to see if the requested state is physically possible.
700 * Only crtcs and planes have check callbacks, so for any additional (global)
701 * checking that a driver needs it can simply wrap that around this function.
702 * Drivers without such needs can directly use this as their
703 * &drm_mode_config_funcs.atomic_check callback.
705 * This just wraps the two parts of the state checking for planes and modeset
706 * state in the default order: First it calls drm_atomic_helper_check_modeset()
707 * and then drm_atomic_helper_check_planes(). The assumption is that the
708 * @drm_plane_helper_funcs.atomic_check and @drm_crtc_helper_funcs.atomic_check
709 * functions depend upon an updated adjusted_mode.clock to e.g. properly compute
713 * Zero for success or -errno
715 int drm_atomic_helper_check(struct drm_device
*dev
,
716 struct drm_atomic_state
*state
)
720 ret
= drm_atomic_helper_check_modeset(dev
, state
);
724 ret
= drm_atomic_helper_check_planes(dev
, state
);
730 EXPORT_SYMBOL(drm_atomic_helper_check
);
733 disable_outputs(struct drm_device
*dev
, struct drm_atomic_state
*old_state
)
735 struct drm_connector
*connector
;
736 struct drm_connector_state
*old_conn_state
, *new_conn_state
;
737 struct drm_crtc
*crtc
;
738 struct drm_crtc_state
*old_crtc_state
, *new_crtc_state
;
741 for_each_oldnew_connector_in_state(old_state
, connector
, old_conn_state
, new_conn_state
, i
) {
742 const struct drm_encoder_helper_funcs
*funcs
;
743 struct drm_encoder
*encoder
;
745 /* Shut down everything that's in the changeset and currently
746 * still on. So need to check the old, saved state. */
747 if (!old_conn_state
->crtc
)
750 old_crtc_state
= drm_atomic_get_old_crtc_state(old_state
, old_conn_state
->crtc
);
752 if (!old_crtc_state
->active
||
753 !drm_atomic_crtc_needs_modeset(old_conn_state
->crtc
->state
))
756 encoder
= old_conn_state
->best_encoder
;
758 /* We shouldn't get this far if we didn't previously have
759 * an encoder.. but WARN_ON() rather than explode.
761 if (WARN_ON(!encoder
))
764 funcs
= encoder
->helper_private
;
766 DRM_DEBUG_ATOMIC("disabling [ENCODER:%d:%s]\n",
767 encoder
->base
.id
, encoder
->name
);
770 * Each encoder has at most one connector (since we always steal
771 * it away), so we won't call disable hooks twice.
773 drm_bridge_disable(encoder
->bridge
);
775 /* Right function depends upon target state. */
777 if (new_conn_state
->crtc
&& funcs
->prepare
)
778 funcs
->prepare(encoder
);
779 else if (funcs
->disable
)
780 funcs
->disable(encoder
);
781 else if (funcs
->dpms
)
782 funcs
->dpms(encoder
, DRM_MODE_DPMS_OFF
);
785 drm_bridge_post_disable(encoder
->bridge
);
788 for_each_oldnew_crtc_in_state(old_state
, crtc
, old_crtc_state
, new_crtc_state
, i
) {
789 const struct drm_crtc_helper_funcs
*funcs
;
791 /* Shut down everything that needs a full modeset. */
792 if (!drm_atomic_crtc_needs_modeset(new_crtc_state
))
795 if (!old_crtc_state
->active
)
798 funcs
= crtc
->helper_private
;
800 DRM_DEBUG_ATOMIC("disabling [CRTC:%d:%s]\n",
801 crtc
->base
.id
, crtc
->name
);
804 /* Right function depends upon target state. */
805 if (new_crtc_state
->enable
&& funcs
->prepare
)
806 funcs
->prepare(crtc
);
807 else if (funcs
->atomic_disable
)
808 funcs
->atomic_disable(crtc
, old_crtc_state
);
809 else if (funcs
->disable
)
810 funcs
->disable(crtc
);
812 funcs
->dpms(crtc
, DRM_MODE_DPMS_OFF
);
817 * drm_atomic_helper_update_legacy_modeset_state - update legacy modeset state
819 * @old_state: atomic state object with old state structures
821 * This function updates all the various legacy modeset state pointers in
822 * connectors, encoders and crtcs. It also updates the timestamping constants
823 * used for precise vblank timestamps by calling
824 * drm_calc_timestamping_constants().
826 * Drivers can use this for building their own atomic commit if they don't have
827 * a pure helper-based modeset implementation.
830 drm_atomic_helper_update_legacy_modeset_state(struct drm_device
*dev
,
831 struct drm_atomic_state
*old_state
)
833 struct drm_connector
*connector
;
834 struct drm_connector_state
*old_conn_state
, *new_conn_state
;
835 struct drm_crtc
*crtc
;
836 struct drm_crtc_state
*new_crtc_state
;
839 /* clear out existing links and update dpms */
840 for_each_oldnew_connector_in_state(old_state
, connector
, old_conn_state
, new_conn_state
, i
) {
841 if (connector
->encoder
) {
842 WARN_ON(!connector
->encoder
->crtc
);
844 connector
->encoder
->crtc
= NULL
;
845 connector
->encoder
= NULL
;
848 crtc
= new_conn_state
->crtc
;
849 if ((!crtc
&& old_conn_state
->crtc
) ||
850 (crtc
&& drm_atomic_crtc_needs_modeset(crtc
->state
))) {
851 struct drm_property
*dpms_prop
=
852 dev
->mode_config
.dpms_property
;
853 int mode
= DRM_MODE_DPMS_OFF
;
855 if (crtc
&& crtc
->state
->active
)
856 mode
= DRM_MODE_DPMS_ON
;
858 connector
->dpms
= mode
;
859 drm_object_property_set_value(&connector
->base
,
865 for_each_new_connector_in_state(old_state
, connector
, new_conn_state
, i
) {
866 if (!new_conn_state
->crtc
)
869 if (WARN_ON(!new_conn_state
->best_encoder
))
872 connector
->encoder
= new_conn_state
->best_encoder
;
873 connector
->encoder
->crtc
= new_conn_state
->crtc
;
876 /* set legacy state in the crtc structure */
877 for_each_new_crtc_in_state(old_state
, crtc
, new_crtc_state
, i
) {
878 struct drm_plane
*primary
= crtc
->primary
;
879 struct drm_plane_state
*new_plane_state
;
881 crtc
->mode
= new_crtc_state
->mode
;
882 crtc
->enabled
= new_crtc_state
->enable
;
885 drm_atomic_get_new_plane_state(old_state
, primary
);
887 if (new_plane_state
&& new_plane_state
->crtc
== crtc
) {
888 crtc
->x
= new_plane_state
->src_x
>> 16;
889 crtc
->y
= new_plane_state
->src_y
>> 16;
892 if (new_crtc_state
->enable
)
893 drm_calc_timestamping_constants(crtc
,
894 &new_crtc_state
->adjusted_mode
);
897 EXPORT_SYMBOL(drm_atomic_helper_update_legacy_modeset_state
);
900 crtc_set_mode(struct drm_device
*dev
, struct drm_atomic_state
*old_state
)
902 struct drm_crtc
*crtc
;
903 struct drm_crtc_state
*new_crtc_state
;
904 struct drm_connector
*connector
;
905 struct drm_connector_state
*new_conn_state
;
908 for_each_new_crtc_in_state(old_state
, crtc
, new_crtc_state
, i
) {
909 const struct drm_crtc_helper_funcs
*funcs
;
911 if (!new_crtc_state
->mode_changed
)
914 funcs
= crtc
->helper_private
;
916 if (new_crtc_state
->enable
&& funcs
->mode_set_nofb
) {
917 DRM_DEBUG_ATOMIC("modeset on [CRTC:%d:%s]\n",
918 crtc
->base
.id
, crtc
->name
);
920 funcs
->mode_set_nofb(crtc
);
924 for_each_new_connector_in_state(old_state
, connector
, new_conn_state
, i
) {
925 const struct drm_encoder_helper_funcs
*funcs
;
926 struct drm_encoder
*encoder
;
927 struct drm_display_mode
*mode
, *adjusted_mode
;
929 if (!new_conn_state
->best_encoder
)
932 encoder
= new_conn_state
->best_encoder
;
933 funcs
= encoder
->helper_private
;
934 new_crtc_state
= new_conn_state
->crtc
->state
;
935 mode
= &new_crtc_state
->mode
;
936 adjusted_mode
= &new_crtc_state
->adjusted_mode
;
938 if (!new_crtc_state
->mode_changed
)
941 DRM_DEBUG_ATOMIC("modeset on [ENCODER:%d:%s]\n",
942 encoder
->base
.id
, encoder
->name
);
945 * Each encoder has at most one connector (since we always steal
946 * it away), so we won't call mode_set hooks twice.
948 if (funcs
&& funcs
->atomic_mode_set
) {
949 funcs
->atomic_mode_set(encoder
, new_crtc_state
,
951 } else if (funcs
&& funcs
->mode_set
) {
952 funcs
->mode_set(encoder
, mode
, adjusted_mode
);
955 drm_bridge_mode_set(encoder
->bridge
, mode
, adjusted_mode
);
960 * drm_atomic_helper_commit_modeset_disables - modeset commit to disable outputs
962 * @old_state: atomic state object with old state structures
964 * This function shuts down all the outputs that need to be shut down and
965 * prepares them (if required) with the new mode.
967 * For compatibility with legacy crtc helpers this should be called before
968 * drm_atomic_helper_commit_planes(), which is what the default commit function
969 * does. But drivers with different needs can group the modeset commits together
970 * and do the plane commits at the end. This is useful for drivers doing runtime
971 * PM since planes updates then only happen when the CRTC is actually enabled.
973 void drm_atomic_helper_commit_modeset_disables(struct drm_device
*dev
,
974 struct drm_atomic_state
*old_state
)
976 disable_outputs(dev
, old_state
);
978 drm_atomic_helper_update_legacy_modeset_state(dev
, old_state
);
980 crtc_set_mode(dev
, old_state
);
982 EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_disables
);
985 * drm_atomic_helper_commit_modeset_enables - modeset commit to enable outputs
987 * @old_state: atomic state object with old state structures
989 * This function enables all the outputs with the new configuration which had to
990 * be turned off for the update.
992 * For compatibility with legacy crtc helpers this should be called after
993 * drm_atomic_helper_commit_planes(), which is what the default commit function
994 * does. But drivers with different needs can group the modeset commits together
995 * and do the plane commits at the end. This is useful for drivers doing runtime
996 * PM since planes updates then only happen when the CRTC is actually enabled.
998 void drm_atomic_helper_commit_modeset_enables(struct drm_device
*dev
,
999 struct drm_atomic_state
*old_state
)
1001 struct drm_crtc
*crtc
;
1002 struct drm_crtc_state
*new_crtc_state
;
1003 struct drm_connector
*connector
;
1004 struct drm_connector_state
*new_conn_state
;
1007 for_each_new_crtc_in_state(old_state
, crtc
, new_crtc_state
, i
) {
1008 const struct drm_crtc_helper_funcs
*funcs
;
1010 /* Need to filter out CRTCs where only planes change. */
1011 if (!drm_atomic_crtc_needs_modeset(new_crtc_state
))
1014 if (!new_crtc_state
->active
)
1017 funcs
= crtc
->helper_private
;
1019 if (new_crtc_state
->enable
) {
1020 DRM_DEBUG_ATOMIC("enabling [CRTC:%d:%s]\n",
1021 crtc
->base
.id
, crtc
->name
);
1024 funcs
->enable(crtc
);
1026 funcs
->commit(crtc
);
1030 for_each_new_connector_in_state(old_state
, connector
, new_conn_state
, i
) {
1031 const struct drm_encoder_helper_funcs
*funcs
;
1032 struct drm_encoder
*encoder
;
1034 if (!new_conn_state
->best_encoder
)
1037 if (!new_conn_state
->crtc
->state
->active
||
1038 !drm_atomic_crtc_needs_modeset(new_conn_state
->crtc
->state
))
1041 encoder
= new_conn_state
->best_encoder
;
1042 funcs
= encoder
->helper_private
;
1044 DRM_DEBUG_ATOMIC("enabling [ENCODER:%d:%s]\n",
1045 encoder
->base
.id
, encoder
->name
);
1048 * Each encoder has at most one connector (since we always steal
1049 * it away), so we won't call enable hooks twice.
1051 drm_bridge_pre_enable(encoder
->bridge
);
1055 funcs
->enable(encoder
);
1056 else if (funcs
->commit
)
1057 funcs
->commit(encoder
);
1060 drm_bridge_enable(encoder
->bridge
);
1063 EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables
);
1066 * drm_atomic_helper_wait_for_fences - wait for fences stashed in plane state
1068 * @state: atomic state object with old state structures
1069 * @pre_swap: If true, do an interruptible wait, and @state is the new state.
1070 * Otherwise @state is the old state.
1072 * For implicit sync, driver should fish the exclusive fence out from the
1073 * incoming fb's and stash it in the drm_plane_state. This is called after
1074 * drm_atomic_helper_swap_state() so it uses the current plane state (and
1075 * just uses the atomic state to find the changed planes)
1077 * Note that @pre_swap is needed since the point where we block for fences moves
1078 * around depending upon whether an atomic commit is blocking or
1079 * non-blocking. For async commit all waiting needs to happen after
1080 * drm_atomic_helper_swap_state() is called, but for synchronous commits we want
1081 * to wait **before** we do anything that can't be easily rolled back. That is
1082 * before we call drm_atomic_helper_swap_state().
1084 * Returns zero if success or < 0 if dma_fence_wait() fails.
1086 int drm_atomic_helper_wait_for_fences(struct drm_device
*dev
,
1087 struct drm_atomic_state
*state
,
1090 struct drm_plane
*plane
;
1091 struct drm_plane_state
*new_plane_state
;
1094 for_each_new_plane_in_state(state
, plane
, new_plane_state
, i
) {
1095 if (!new_plane_state
->fence
)
1098 WARN_ON(!new_plane_state
->fb
);
1101 * If waiting for fences pre-swap (ie: nonblock), userspace can
1102 * still interrupt the operation. Instead of blocking until the
1103 * timer expires, make the wait interruptible.
1105 ret
= dma_fence_wait(new_plane_state
->fence
, pre_swap
);
1109 dma_fence_put(new_plane_state
->fence
);
1110 new_plane_state
->fence
= NULL
;
1115 EXPORT_SYMBOL(drm_atomic_helper_wait_for_fences
);
1118 * drm_atomic_helper_wait_for_vblanks - wait for vblank on crtcs
1120 * @old_state: atomic state object with old state structures
1122 * Helper to, after atomic commit, wait for vblanks on all effected
1123 * crtcs (ie. before cleaning up old framebuffers using
1124 * drm_atomic_helper_cleanup_planes()). It will only wait on crtcs where the
1125 * framebuffers have actually changed to optimize for the legacy cursor and
1126 * plane update use-case.
1129 drm_atomic_helper_wait_for_vblanks(struct drm_device
*dev
,
1130 struct drm_atomic_state
*old_state
)
1132 struct drm_crtc
*crtc
;
1133 struct drm_crtc_state
*old_crtc_state
, *new_crtc_state
;
1135 unsigned crtc_mask
= 0;
1138 * Legacy cursor ioctls are completely unsynced, and userspace
1139 * relies on that (by doing tons of cursor updates).
1141 if (old_state
->legacy_cursor_update
)
1144 for_each_oldnew_crtc_in_state(old_state
, crtc
, old_crtc_state
, new_crtc_state
, i
) {
1145 if (!new_crtc_state
->active
|| !new_crtc_state
->planes_changed
)
1148 ret
= drm_crtc_vblank_get(crtc
);
1152 crtc_mask
|= drm_crtc_mask(crtc
);
1153 old_state
->crtcs
[i
].last_vblank_count
= drm_crtc_vblank_count(crtc
);
1156 for_each_old_crtc_in_state(old_state
, crtc
, old_crtc_state
, i
) {
1157 if (!(crtc_mask
& drm_crtc_mask(crtc
)))
1160 ret
= wait_event_timeout(dev
->vblank
[i
].queue
,
1161 old_state
->crtcs
[i
].last_vblank_count
!=
1162 drm_crtc_vblank_count(crtc
),
1163 msecs_to_jiffies(50));
1165 WARN(!ret
, "[CRTC:%d:%s] vblank wait timed out\n",
1166 crtc
->base
.id
, crtc
->name
);
1168 drm_crtc_vblank_put(crtc
);
1171 EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks
);
1174 * drm_atomic_helper_commit_tail - commit atomic update to hardware
1175 * @old_state: atomic state object with old state structures
1177 * This is the default implementation for the
1178 * &drm_mode_config_helper_funcs.atomic_commit_tail hook.
1180 * Note that the default ordering of how the various stages are called is to
1181 * match the legacy modeset helper library closest. One peculiarity of that is
1182 * that it doesn't mesh well with runtime PM at all.
1184 * For drivers supporting runtime PM the recommended sequence is instead ::
1186 * drm_atomic_helper_commit_modeset_disables(dev, old_state);
1188 * drm_atomic_helper_commit_modeset_enables(dev, old_state);
1190 * drm_atomic_helper_commit_planes(dev, old_state,
1191 * DRM_PLANE_COMMIT_ACTIVE_ONLY);
1193 * for committing the atomic update to hardware. See the kerneldoc entries for
1194 * these three functions for more details.
1196 void drm_atomic_helper_commit_tail(struct drm_atomic_state
*old_state
)
1198 struct drm_device
*dev
= old_state
->dev
;
1200 drm_atomic_helper_commit_modeset_disables(dev
, old_state
);
1202 drm_atomic_helper_commit_planes(dev
, old_state
, 0);
1204 drm_atomic_helper_commit_modeset_enables(dev
, old_state
);
1206 drm_atomic_helper_commit_hw_done(old_state
);
1208 drm_atomic_helper_wait_for_vblanks(dev
, old_state
);
1210 drm_atomic_helper_cleanup_planes(dev
, old_state
);
1212 EXPORT_SYMBOL(drm_atomic_helper_commit_tail
);
1214 static void commit_tail(struct drm_atomic_state
*old_state
)
1216 struct drm_device
*dev
= old_state
->dev
;
1217 const struct drm_mode_config_helper_funcs
*funcs
;
1219 funcs
= dev
->mode_config
.helper_private
;
1221 drm_atomic_helper_wait_for_fences(dev
, old_state
, false);
1223 drm_atomic_helper_wait_for_dependencies(old_state
);
1225 if (funcs
&& funcs
->atomic_commit_tail
)
1226 funcs
->atomic_commit_tail(old_state
);
1228 drm_atomic_helper_commit_tail(old_state
);
1230 drm_atomic_helper_commit_cleanup_done(old_state
);
1232 drm_atomic_state_put(old_state
);
1235 static void commit_work(struct work_struct
*work
)
1237 struct drm_atomic_state
*state
= container_of(work
,
1238 struct drm_atomic_state
,
1244 * drm_atomic_helper_commit - commit validated state object
1246 * @state: the driver state object
1247 * @nonblock: whether nonblocking behavior is requested.
1249 * This function commits a with drm_atomic_helper_check() pre-validated state
1250 * object. This can still fail when e.g. the framebuffer reservation fails. This
1251 * function implements nonblocking commits, using
1252 * drm_atomic_helper_setup_commit() and related functions.
1254 * Committing the actual hardware state is done through the
1255 * &drm_mode_config_helper_funcs.atomic_commit_tail callback, or it's default
1256 * implementation drm_atomic_helper_commit_tail().
1259 * Zero for success or -errno.
1261 int drm_atomic_helper_commit(struct drm_device
*dev
,
1262 struct drm_atomic_state
*state
,
1267 ret
= drm_atomic_helper_setup_commit(state
, nonblock
);
1271 INIT_WORK(&state
->commit_work
, commit_work
);
1273 ret
= drm_atomic_helper_prepare_planes(dev
, state
);
1278 ret
= drm_atomic_helper_wait_for_fences(dev
, state
, true);
1280 drm_atomic_helper_cleanup_planes(dev
, state
);
1286 * This is the point of no return - everything below never fails except
1287 * when the hw goes bonghits. Which means we can commit the new state on
1288 * the software side now.
1291 drm_atomic_helper_swap_state(state
, true);
1294 * Everything below can be run asynchronously without the need to grab
1295 * any modeset locks at all under one condition: It must be guaranteed
1296 * that the asynchronous work has either been cancelled (if the driver
1297 * supports it, which at least requires that the framebuffers get
1298 * cleaned up with drm_atomic_helper_cleanup_planes()) or completed
1299 * before the new state gets committed on the software side with
1300 * drm_atomic_helper_swap_state().
1302 * This scheme allows new atomic state updates to be prepared and
1303 * checked in parallel to the asynchronous completion of the previous
1304 * update. Which is important since compositors need to figure out the
1305 * composition of the next frame right after having submitted the
1308 * NOTE: Commit work has multiple phases, first hardware commit, then
1309 * cleanup. We want them to overlap, hence need system_unbound_wq to
1310 * make sure work items don't artifically stall on each another.
1313 drm_atomic_state_get(state
);
1315 queue_work(system_unbound_wq
, &state
->commit_work
);
1321 EXPORT_SYMBOL(drm_atomic_helper_commit
);
1324 * DOC: implementing nonblocking commit
1326 * Nonblocking atomic commits have to be implemented in the following sequence:
1328 * 1. Run drm_atomic_helper_prepare_planes() first. This is the only function
1329 * which commit needs to call which can fail, so we want to run it first and
1332 * 2. Synchronize with any outstanding nonblocking commit worker threads which
1333 * might be affected the new state update. This can be done by either cancelling
1334 * or flushing the work items, depending upon whether the driver can deal with
1335 * cancelled updates. Note that it is important to ensure that the framebuffer
1336 * cleanup is still done when cancelling.
1338 * Asynchronous workers need to have sufficient parallelism to be able to run
1339 * different atomic commits on different CRTCs in parallel. The simplest way to
1340 * achive this is by running them on the &system_unbound_wq work queue. Note
1341 * that drivers are not required to split up atomic commits and run an
1342 * individual commit in parallel - userspace is supposed to do that if it cares.
1343 * But it might be beneficial to do that for modesets, since those necessarily
1344 * must be done as one global operation, and enabling or disabling a CRTC can
1345 * take a long time. But even that is not required.
1347 * 3. The software state is updated synchronously with
1348 * drm_atomic_helper_swap_state(). Doing this under the protection of all modeset
1349 * locks means concurrent callers never see inconsistent state. And doing this
1350 * while it's guaranteed that no relevant nonblocking worker runs means that
1351 * nonblocking workers do not need grab any locks. Actually they must not grab
1352 * locks, for otherwise the work flushing will deadlock.
1354 * 4. Schedule a work item to do all subsequent steps, using the split-out
1355 * commit helpers: a) pre-plane commit b) plane commit c) post-plane commit and
1356 * then cleaning up the framebuffers after the old framebuffer is no longer
1359 * The above scheme is implemented in the atomic helper libraries in
1360 * drm_atomic_helper_commit() using a bunch of helper functions. See
1361 * drm_atomic_helper_setup_commit() for a starting point.
1364 static int stall_checks(struct drm_crtc
*crtc
, bool nonblock
)
1366 struct drm_crtc_commit
*commit
, *stall_commit
= NULL
;
1367 bool completed
= true;
1371 spin_lock(&crtc
->commit_lock
);
1373 list_for_each_entry(commit
, &crtc
->commit_list
, commit_entry
) {
1375 completed
= try_wait_for_completion(&commit
->flip_done
);
1376 /* Userspace is not allowed to get ahead of the previous
1377 * commit with nonblocking ones. */
1378 if (!completed
&& nonblock
) {
1379 spin_unlock(&crtc
->commit_lock
);
1382 } else if (i
== 1) {
1383 stall_commit
= commit
;
1384 drm_crtc_commit_get(stall_commit
);
1390 spin_unlock(&crtc
->commit_lock
);
1395 /* We don't want to let commits get ahead of cleanup work too much,
1396 * stalling on 2nd previous commit means triple-buffer won't ever stall.
1398 ret
= wait_for_completion_interruptible_timeout(&stall_commit
->cleanup_done
,
1401 DRM_ERROR("[CRTC:%d:%s] cleanup_done timed out\n",
1402 crtc
->base
.id
, crtc
->name
);
1404 drm_crtc_commit_put(stall_commit
);
1406 return ret
< 0 ? ret
: 0;
1409 static void release_crtc_commit(struct completion
*completion
)
1411 struct drm_crtc_commit
*commit
= container_of(completion
,
1415 drm_crtc_commit_put(commit
);
1419 * drm_atomic_helper_setup_commit - setup possibly nonblocking commit
1420 * @state: new modeset state to be committed
1421 * @nonblock: whether nonblocking behavior is requested.
1423 * This function prepares @state to be used by the atomic helper's support for
1424 * nonblocking commits. Drivers using the nonblocking commit infrastructure
1425 * should always call this function from their
1426 * &drm_mode_config_funcs.atomic_commit hook.
1428 * To be able to use this support drivers need to use a few more helper
1429 * functions. drm_atomic_helper_wait_for_dependencies() must be called before
1430 * actually committing the hardware state, and for nonblocking commits this call
1431 * must be placed in the async worker. See also drm_atomic_helper_swap_state()
1432 * and it's stall parameter, for when a driver's commit hooks look at the
1433 * &drm_crtc.state, &drm_plane.state or &drm_connector.state pointer directly.
1435 * Completion of the hardware commit step must be signalled using
1436 * drm_atomic_helper_commit_hw_done(). After this step the driver is not allowed
1437 * to read or change any permanent software or hardware modeset state. The only
1438 * exception is state protected by other means than &drm_modeset_lock locks.
1439 * Only the free standing @state with pointers to the old state structures can
1440 * be inspected, e.g. to clean up old buffers using
1441 * drm_atomic_helper_cleanup_planes().
1443 * At the very end, before cleaning up @state drivers must call
1444 * drm_atomic_helper_commit_cleanup_done().
1446 * This is all implemented by in drm_atomic_helper_commit(), giving drivers a
1447 * complete and esay-to-use default implementation of the atomic_commit() hook.
1449 * The tracking of asynchronously executed and still pending commits is done
1450 * using the core structure &drm_crtc_commit.
1452 * By default there's no need to clean up resources allocated by this function
1453 * explicitly: drm_atomic_state_default_clear() will take care of that
1458 * 0 on success. -EBUSY when userspace schedules nonblocking commits too fast,
1459 * -ENOMEM on allocation failures and -EINTR when a signal is pending.
1461 int drm_atomic_helper_setup_commit(struct drm_atomic_state
*state
,
1464 struct drm_crtc
*crtc
;
1465 struct drm_crtc_state
*old_crtc_state
, *new_crtc_state
;
1466 struct drm_crtc_commit
*commit
;
1469 for_each_oldnew_crtc_in_state(state
, crtc
, old_crtc_state
, new_crtc_state
, i
) {
1470 commit
= kzalloc(sizeof(*commit
), GFP_KERNEL
);
1474 init_completion(&commit
->flip_done
);
1475 init_completion(&commit
->hw_done
);
1476 init_completion(&commit
->cleanup_done
);
1477 INIT_LIST_HEAD(&commit
->commit_entry
);
1478 kref_init(&commit
->ref
);
1479 commit
->crtc
= crtc
;
1481 state
->crtcs
[i
].commit
= commit
;
1483 ret
= stall_checks(crtc
, nonblock
);
1487 /* Drivers only send out events when at least either current or
1488 * new CRTC state is active. Complete right away if everything
1490 if (!old_crtc_state
->active
&& !new_crtc_state
->active
) {
1491 complete_all(&commit
->flip_done
);
1495 /* Legacy cursor updates are fully unsynced. */
1496 if (state
->legacy_cursor_update
) {
1497 complete_all(&commit
->flip_done
);
1501 if (!new_crtc_state
->event
) {
1502 commit
->event
= kzalloc(sizeof(*commit
->event
),
1507 new_crtc_state
->event
= commit
->event
;
1510 new_crtc_state
->event
->base
.completion
= &commit
->flip_done
;
1511 new_crtc_state
->event
->base
.completion_release
= release_crtc_commit
;
1512 drm_crtc_commit_get(commit
);
1517 EXPORT_SYMBOL(drm_atomic_helper_setup_commit
);
1520 static struct drm_crtc_commit
*preceeding_commit(struct drm_crtc
*crtc
)
1522 struct drm_crtc_commit
*commit
;
1525 list_for_each_entry(commit
, &crtc
->commit_list
, commit_entry
) {
1526 /* skip the first entry, that's the current commit */
1536 * drm_atomic_helper_wait_for_dependencies - wait for required preceeding commits
1537 * @old_state: atomic state object with old state structures
1539 * This function waits for all preceeding commits that touch the same CRTC as
1540 * @old_state to both be committed to the hardware (as signalled by
1541 * drm_atomic_helper_commit_hw_done) and executed by the hardware (as signalled
1542 * by calling drm_crtc_vblank_send_event() on the &drm_crtc_state.event).
1544 * This is part of the atomic helper support for nonblocking commits, see
1545 * drm_atomic_helper_setup_commit() for an overview.
1547 void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state
*old_state
)
1549 struct drm_crtc
*crtc
;
1550 struct drm_crtc_state
*new_crtc_state
;
1551 struct drm_crtc_commit
*commit
;
1555 for_each_new_crtc_in_state(old_state
, crtc
, new_crtc_state
, i
) {
1556 spin_lock(&crtc
->commit_lock
);
1557 commit
= preceeding_commit(crtc
);
1559 drm_crtc_commit_get(commit
);
1560 spin_unlock(&crtc
->commit_lock
);
1565 ret
= wait_for_completion_timeout(&commit
->hw_done
,
1568 DRM_ERROR("[CRTC:%d:%s] hw_done timed out\n",
1569 crtc
->base
.id
, crtc
->name
);
1571 /* Currently no support for overwriting flips, hence
1572 * stall for previous one to execute completely. */
1573 ret
= wait_for_completion_timeout(&commit
->flip_done
,
1576 DRM_ERROR("[CRTC:%d:%s] flip_done timed out\n",
1577 crtc
->base
.id
, crtc
->name
);
1579 drm_crtc_commit_put(commit
);
1582 EXPORT_SYMBOL(drm_atomic_helper_wait_for_dependencies
);
1585 * drm_atomic_helper_commit_hw_done - setup possible nonblocking commit
1586 * @old_state: atomic state object with old state structures
1588 * This function is used to signal completion of the hardware commit step. After
1589 * this step the driver is not allowed to read or change any permanent software
1590 * or hardware modeset state. The only exception is state protected by other
1591 * means than &drm_modeset_lock locks.
1593 * Drivers should try to postpone any expensive or delayed cleanup work after
1594 * this function is called.
1596 * This is part of the atomic helper support for nonblocking commits, see
1597 * drm_atomic_helper_setup_commit() for an overview.
1599 void drm_atomic_helper_commit_hw_done(struct drm_atomic_state
*old_state
)
1601 struct drm_crtc
*crtc
;
1602 struct drm_crtc_state
*new_crtc_state
;
1603 struct drm_crtc_commit
*commit
;
1606 for_each_new_crtc_in_state(old_state
, crtc
, new_crtc_state
, i
) {
1607 commit
= old_state
->crtcs
[i
].commit
;
1611 /* backend must have consumed any event by now */
1612 WARN_ON(new_crtc_state
->event
);
1613 spin_lock(&crtc
->commit_lock
);
1614 complete_all(&commit
->hw_done
);
1615 spin_unlock(&crtc
->commit_lock
);
1618 EXPORT_SYMBOL(drm_atomic_helper_commit_hw_done
);
1621 * drm_atomic_helper_commit_cleanup_done - signal completion of commit
1622 * @old_state: atomic state object with old state structures
1624 * This signals completion of the atomic update @old_state, including any
1625 * cleanup work. If used, it must be called right before calling
1626 * drm_atomic_state_put().
1628 * This is part of the atomic helper support for nonblocking commits, see
1629 * drm_atomic_helper_setup_commit() for an overview.
1631 void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_state
*old_state
)
1633 struct drm_crtc
*crtc
;
1634 struct drm_crtc_state
*new_crtc_state
;
1635 struct drm_crtc_commit
*commit
;
1639 for_each_new_crtc_in_state(old_state
, crtc
, new_crtc_state
, i
) {
1640 commit
= old_state
->crtcs
[i
].commit
;
1641 if (WARN_ON(!commit
))
1644 spin_lock(&crtc
->commit_lock
);
1645 complete_all(&commit
->cleanup_done
);
1646 WARN_ON(!try_wait_for_completion(&commit
->hw_done
));
1648 /* commit_list borrows our reference, need to remove before we
1649 * clean up our drm_atomic_state. But only after it actually
1650 * completed, otherwise subsequent commits won't stall properly. */
1651 if (try_wait_for_completion(&commit
->flip_done
))
1654 spin_unlock(&crtc
->commit_lock
);
1656 /* We must wait for the vblank event to signal our completion
1657 * before releasing our reference, since the vblank work does
1658 * not hold a reference of its own. */
1659 ret
= wait_for_completion_timeout(&commit
->flip_done
,
1662 DRM_ERROR("[CRTC:%d:%s] flip_done timed out\n",
1663 crtc
->base
.id
, crtc
->name
);
1665 spin_lock(&crtc
->commit_lock
);
1667 list_del(&commit
->commit_entry
);
1668 spin_unlock(&crtc
->commit_lock
);
1671 EXPORT_SYMBOL(drm_atomic_helper_commit_cleanup_done
);
1674 * drm_atomic_helper_prepare_planes - prepare plane resources before commit
1676 * @state: atomic state object with new state structures
1678 * This function prepares plane state, specifically framebuffers, for the new
1679 * configuration, by calling &drm_plane_helper_funcs.prepare_fb. If any failure
1680 * is encountered this function will call &drm_plane_helper_funcs.cleanup_fb on
1681 * any already successfully prepared framebuffer.
1684 * 0 on success, negative error code on failure.
1686 int drm_atomic_helper_prepare_planes(struct drm_device
*dev
,
1687 struct drm_atomic_state
*state
)
1689 struct drm_plane
*plane
;
1690 struct drm_plane_state
*new_plane_state
;
1693 for_each_new_plane_in_state(state
, plane
, new_plane_state
, i
) {
1694 const struct drm_plane_helper_funcs
*funcs
;
1696 funcs
= plane
->helper_private
;
1698 if (funcs
->prepare_fb
) {
1699 ret
= funcs
->prepare_fb(plane
, new_plane_state
);
1708 for_each_new_plane_in_state(state
, plane
, new_plane_state
, j
) {
1709 const struct drm_plane_helper_funcs
*funcs
;
1714 funcs
= plane
->helper_private
;
1716 if (funcs
->cleanup_fb
)
1717 funcs
->cleanup_fb(plane
, new_plane_state
);
1722 EXPORT_SYMBOL(drm_atomic_helper_prepare_planes
);
1724 static bool plane_crtc_active(const struct drm_plane_state
*state
)
1726 return state
->crtc
&& state
->crtc
->state
->active
;
1730 * drm_atomic_helper_commit_planes - commit plane state
1732 * @old_state: atomic state object with old state structures
1733 * @flags: flags for committing plane state
1735 * This function commits the new plane state using the plane and atomic helper
1736 * functions for planes and crtcs. It assumes that the atomic state has already
1737 * been pushed into the relevant object state pointers, since this step can no
1740 * It still requires the global state object @old_state to know which planes and
1741 * crtcs need to be updated though.
1743 * Note that this function does all plane updates across all CRTCs in one step.
1744 * If the hardware can't support this approach look at
1745 * drm_atomic_helper_commit_planes_on_crtc() instead.
1747 * Plane parameters can be updated by applications while the associated CRTC is
1748 * disabled. The DRM/KMS core will store the parameters in the plane state,
1749 * which will be available to the driver when the CRTC is turned on. As a result
1750 * most drivers don't need to be immediately notified of plane updates for a
1753 * Unless otherwise needed, drivers are advised to set the ACTIVE_ONLY flag in
1754 * @flags in order not to receive plane update notifications related to a
1755 * disabled CRTC. This avoids the need to manually ignore plane updates in
1756 * driver code when the driver and/or hardware can't or just don't need to deal
1757 * with updates on disabled CRTCs, for example when supporting runtime PM.
1759 * Drivers may set the NO_DISABLE_AFTER_MODESET flag in @flags if the relevant
1760 * display controllers require to disable a CRTC's planes when the CRTC is
1761 * disabled. This function would skip the &drm_plane_helper_funcs.atomic_disable
1762 * call for a plane if the CRTC of the old plane state needs a modesetting
1763 * operation. Of course, the drivers need to disable the planes in their CRTC
1764 * disable callbacks since no one else would do that.
1766 * The drm_atomic_helper_commit() default implementation doesn't set the
1767 * ACTIVE_ONLY flag to most closely match the behaviour of the legacy helpers.
1768 * This should not be copied blindly by drivers.
1770 void drm_atomic_helper_commit_planes(struct drm_device
*dev
,
1771 struct drm_atomic_state
*old_state
,
1774 struct drm_crtc
*crtc
;
1775 struct drm_crtc_state
*old_crtc_state
, *new_crtc_state
;
1776 struct drm_plane
*plane
;
1777 struct drm_plane_state
*old_plane_state
, *new_plane_state
;
1779 bool active_only
= flags
& DRM_PLANE_COMMIT_ACTIVE_ONLY
;
1780 bool no_disable
= flags
& DRM_PLANE_COMMIT_NO_DISABLE_AFTER_MODESET
;
1782 for_each_oldnew_crtc_in_state(old_state
, crtc
, old_crtc_state
, new_crtc_state
, i
) {
1783 const struct drm_crtc_helper_funcs
*funcs
;
1785 funcs
= crtc
->helper_private
;
1787 if (!funcs
|| !funcs
->atomic_begin
)
1790 if (active_only
&& !new_crtc_state
->active
)
1793 funcs
->atomic_begin(crtc
, old_crtc_state
);
1796 for_each_oldnew_plane_in_state(old_state
, plane
, old_plane_state
, new_plane_state
, i
) {
1797 const struct drm_plane_helper_funcs
*funcs
;
1800 funcs
= plane
->helper_private
;
1805 disabling
= drm_atomic_plane_disabling(old_plane_state
,
1810 * Skip planes related to inactive CRTCs. If the plane
1811 * is enabled use the state of the current CRTC. If the
1812 * plane is being disabled use the state of the old
1813 * CRTC to avoid skipping planes being disabled on an
1816 if (!disabling
&& !plane_crtc_active(new_plane_state
))
1818 if (disabling
&& !plane_crtc_active(old_plane_state
))
1823 * Special-case disabling the plane if drivers support it.
1825 if (disabling
&& funcs
->atomic_disable
) {
1826 struct drm_crtc_state
*crtc_state
;
1828 crtc_state
= old_plane_state
->crtc
->state
;
1830 if (drm_atomic_crtc_needs_modeset(crtc_state
) &&
1834 funcs
->atomic_disable(plane
, old_plane_state
);
1835 } else if (new_plane_state
->crtc
|| disabling
) {
1836 funcs
->atomic_update(plane
, old_plane_state
);
1840 for_each_oldnew_crtc_in_state(old_state
, crtc
, old_crtc_state
, new_crtc_state
, i
) {
1841 const struct drm_crtc_helper_funcs
*funcs
;
1843 funcs
= crtc
->helper_private
;
1845 if (!funcs
|| !funcs
->atomic_flush
)
1848 if (active_only
&& !new_crtc_state
->active
)
1851 funcs
->atomic_flush(crtc
, old_crtc_state
);
1854 EXPORT_SYMBOL(drm_atomic_helper_commit_planes
);
1857 * drm_atomic_helper_commit_planes_on_crtc - commit plane state for a crtc
1858 * @old_crtc_state: atomic state object with the old crtc state
1860 * This function commits the new plane state using the plane and atomic helper
1861 * functions for planes on the specific crtc. It assumes that the atomic state
1862 * has already been pushed into the relevant object state pointers, since this
1863 * step can no longer fail.
1865 * This function is useful when plane updates should be done crtc-by-crtc
1866 * instead of one global step like drm_atomic_helper_commit_planes() does.
1868 * This function can only be savely used when planes are not allowed to move
1869 * between different CRTCs because this function doesn't handle inter-CRTC
1870 * depencies. Callers need to ensure that either no such depencies exist,
1871 * resolve them through ordering of commit calls or through some other means.
1874 drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state
*old_crtc_state
)
1876 const struct drm_crtc_helper_funcs
*crtc_funcs
;
1877 struct drm_crtc
*crtc
= old_crtc_state
->crtc
;
1878 struct drm_atomic_state
*old_state
= old_crtc_state
->state
;
1879 struct drm_plane
*plane
;
1880 unsigned plane_mask
;
1882 plane_mask
= old_crtc_state
->plane_mask
;
1883 plane_mask
|= crtc
->state
->plane_mask
;
1885 crtc_funcs
= crtc
->helper_private
;
1886 if (crtc_funcs
&& crtc_funcs
->atomic_begin
)
1887 crtc_funcs
->atomic_begin(crtc
, old_crtc_state
);
1889 drm_for_each_plane_mask(plane
, crtc
->dev
, plane_mask
) {
1890 struct drm_plane_state
*old_plane_state
=
1891 drm_atomic_get_old_plane_state(old_state
, plane
);
1892 const struct drm_plane_helper_funcs
*plane_funcs
;
1894 plane_funcs
= plane
->helper_private
;
1896 if (!old_plane_state
|| !plane_funcs
)
1899 WARN_ON(plane
->state
->crtc
&& plane
->state
->crtc
!= crtc
);
1901 if (drm_atomic_plane_disabling(old_plane_state
, plane
->state
) &&
1902 plane_funcs
->atomic_disable
)
1903 plane_funcs
->atomic_disable(plane
, old_plane_state
);
1904 else if (plane
->state
->crtc
||
1905 drm_atomic_plane_disabling(old_plane_state
, plane
->state
))
1906 plane_funcs
->atomic_update(plane
, old_plane_state
);
1909 if (crtc_funcs
&& crtc_funcs
->atomic_flush
)
1910 crtc_funcs
->atomic_flush(crtc
, old_crtc_state
);
1912 EXPORT_SYMBOL(drm_atomic_helper_commit_planes_on_crtc
);
1915 * drm_atomic_helper_disable_planes_on_crtc - helper to disable CRTC's planes
1916 * @old_crtc_state: atomic state object with the old CRTC state
1917 * @atomic: if set, synchronize with CRTC's atomic_begin/flush hooks
1919 * Disables all planes associated with the given CRTC. This can be
1920 * used for instance in the CRTC helper atomic_disable callback to disable
1923 * If the atomic-parameter is set the function calls the CRTC's
1924 * atomic_begin hook before and atomic_flush hook after disabling the
1927 * It is a bug to call this function without having implemented the
1928 * &drm_plane_helper_funcs.atomic_disable plane hook.
1931 drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc_state
*old_crtc_state
,
1934 struct drm_crtc
*crtc
= old_crtc_state
->crtc
;
1935 const struct drm_crtc_helper_funcs
*crtc_funcs
=
1936 crtc
->helper_private
;
1937 struct drm_plane
*plane
;
1939 if (atomic
&& crtc_funcs
&& crtc_funcs
->atomic_begin
)
1940 crtc_funcs
->atomic_begin(crtc
, NULL
);
1942 drm_atomic_crtc_state_for_each_plane(plane
, old_crtc_state
) {
1943 const struct drm_plane_helper_funcs
*plane_funcs
=
1944 plane
->helper_private
;
1949 WARN_ON(!plane_funcs
->atomic_disable
);
1950 if (plane_funcs
->atomic_disable
)
1951 plane_funcs
->atomic_disable(plane
, NULL
);
1954 if (atomic
&& crtc_funcs
&& crtc_funcs
->atomic_flush
)
1955 crtc_funcs
->atomic_flush(crtc
, NULL
);
1957 EXPORT_SYMBOL(drm_atomic_helper_disable_planes_on_crtc
);
1960 * drm_atomic_helper_cleanup_planes - cleanup plane resources after commit
1962 * @old_state: atomic state object with old state structures
1964 * This function cleans up plane state, specifically framebuffers, from the old
1965 * configuration. Hence the old configuration must be perserved in @old_state to
1966 * be able to call this function.
1968 * This function must also be called on the new state when the atomic update
1969 * fails at any point after calling drm_atomic_helper_prepare_planes().
1971 void drm_atomic_helper_cleanup_planes(struct drm_device
*dev
,
1972 struct drm_atomic_state
*old_state
)
1974 struct drm_plane
*plane
;
1975 struct drm_plane_state
*old_plane_state
, *new_plane_state
;
1978 for_each_oldnew_plane_in_state(old_state
, plane
, old_plane_state
, new_plane_state
, i
) {
1979 const struct drm_plane_helper_funcs
*funcs
;
1980 struct drm_plane_state
*plane_state
;
1983 * This might be called before swapping when commit is aborted,
1984 * in which case we have to cleanup the new state.
1986 if (old_plane_state
== plane
->state
)
1987 plane_state
= new_plane_state
;
1989 plane_state
= old_plane_state
;
1991 funcs
= plane
->helper_private
;
1993 if (funcs
->cleanup_fb
)
1994 funcs
->cleanup_fb(plane
, plane_state
);
1997 EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes
);
2000 * drm_atomic_helper_swap_state - store atomic state into current sw state
2001 * @state: atomic state
2002 * @stall: stall for proceeding commits
2004 * This function stores the atomic state into the current state pointers in all
2005 * driver objects. It should be called after all failing steps have been done
2006 * and succeeded, but before the actual hardware state is committed.
2008 * For cleanup and error recovery the current state for all changed objects will
2009 * be swaped into @state.
2011 * With that sequence it fits perfectly into the plane prepare/cleanup sequence:
2013 * 1. Call drm_atomic_helper_prepare_planes() with the staged atomic state.
2015 * 2. Do any other steps that might fail.
2017 * 3. Put the staged state into the current state pointers with this function.
2019 * 4. Actually commit the hardware state.
2021 * 5. Call drm_atomic_helper_cleanup_planes() with @state, which since step 3
2022 * contains the old state. Also do any other cleanup required with that state.
2024 * @stall must be set when nonblocking commits for this driver directly access
2025 * the &drm_plane.state, &drm_crtc.state or &drm_connector.state pointer. With
2026 * the current atomic helpers this is almost always the case, since the helpers
2027 * don't pass the right state structures to the callbacks.
2029 void drm_atomic_helper_swap_state(struct drm_atomic_state
*state
,
2034 struct drm_connector
*connector
;
2035 struct drm_connector_state
*old_conn_state
, *new_conn_state
;
2036 struct drm_crtc
*crtc
;
2037 struct drm_crtc_state
*old_crtc_state
, *new_crtc_state
;
2038 struct drm_plane
*plane
;
2039 struct drm_plane_state
*old_plane_state
, *new_plane_state
;
2040 struct drm_crtc_commit
*commit
;
2043 for_each_new_crtc_in_state(state
, crtc
, new_crtc_state
, i
) {
2044 spin_lock(&crtc
->commit_lock
);
2045 commit
= list_first_entry_or_null(&crtc
->commit_list
,
2046 struct drm_crtc_commit
, commit_entry
);
2048 drm_crtc_commit_get(commit
);
2049 spin_unlock(&crtc
->commit_lock
);
2054 ret
= wait_for_completion_timeout(&commit
->hw_done
,
2057 DRM_ERROR("[CRTC:%d:%s] hw_done timed out\n",
2058 crtc
->base
.id
, crtc
->name
);
2059 drm_crtc_commit_put(commit
);
2063 for_each_oldnew_connector_in_state(state
, connector
, old_conn_state
, new_conn_state
, i
) {
2064 WARN_ON(connector
->state
!= old_conn_state
);
2066 old_conn_state
->state
= state
;
2067 new_conn_state
->state
= NULL
;
2069 state
->connectors
[i
].state
= old_conn_state
;
2070 connector
->state
= new_conn_state
;
2073 for_each_oldnew_crtc_in_state(state
, crtc
, old_crtc_state
, new_crtc_state
, i
) {
2074 WARN_ON(crtc
->state
!= old_crtc_state
);
2076 old_crtc_state
->state
= state
;
2077 new_crtc_state
->state
= NULL
;
2079 state
->crtcs
[i
].state
= old_crtc_state
;
2080 crtc
->state
= new_crtc_state
;
2082 if (state
->crtcs
[i
].commit
) {
2083 spin_lock(&crtc
->commit_lock
);
2084 list_add(&state
->crtcs
[i
].commit
->commit_entry
,
2085 &crtc
->commit_list
);
2086 spin_unlock(&crtc
->commit_lock
);
2088 state
->crtcs
[i
].commit
->event
= NULL
;
2092 for_each_oldnew_plane_in_state(state
, plane
, old_plane_state
, new_plane_state
, i
) {
2093 WARN_ON(plane
->state
!= old_plane_state
);
2095 old_plane_state
->state
= state
;
2096 new_plane_state
->state
= NULL
;
2098 state
->planes
[i
].state
= old_plane_state
;
2099 plane
->state
= new_plane_state
;
2102 EXPORT_SYMBOL(drm_atomic_helper_swap_state
);
2105 * drm_atomic_helper_update_plane - Helper for primary plane update using atomic
2106 * @plane: plane object to update
2107 * @crtc: owning CRTC of owning plane
2108 * @fb: framebuffer to flip onto plane
2109 * @crtc_x: x offset of primary plane on crtc
2110 * @crtc_y: y offset of primary plane on crtc
2111 * @crtc_w: width of primary plane rectangle on crtc
2112 * @crtc_h: height of primary plane rectangle on crtc
2113 * @src_x: x offset of @fb for panning
2114 * @src_y: y offset of @fb for panning
2115 * @src_w: width of source rectangle in @fb
2116 * @src_h: height of source rectangle in @fb
2117 * @ctx: lock acquire context
2119 * Provides a default plane update handler using the atomic driver interface.
2122 * Zero on success, error code on failure
2124 int drm_atomic_helper_update_plane(struct drm_plane
*plane
,
2125 struct drm_crtc
*crtc
,
2126 struct drm_framebuffer
*fb
,
2127 int crtc_x
, int crtc_y
,
2128 unsigned int crtc_w
, unsigned int crtc_h
,
2129 uint32_t src_x
, uint32_t src_y
,
2130 uint32_t src_w
, uint32_t src_h
,
2131 struct drm_modeset_acquire_ctx
*ctx
)
2133 struct drm_atomic_state
*state
;
2134 struct drm_plane_state
*plane_state
;
2137 state
= drm_atomic_state_alloc(plane
->dev
);
2141 state
->acquire_ctx
= ctx
;
2142 plane_state
= drm_atomic_get_plane_state(state
, plane
);
2143 if (IS_ERR(plane_state
)) {
2144 ret
= PTR_ERR(plane_state
);
2148 ret
= drm_atomic_set_crtc_for_plane(plane_state
, crtc
);
2151 drm_atomic_set_fb_for_plane(plane_state
, fb
);
2152 plane_state
->crtc_x
= crtc_x
;
2153 plane_state
->crtc_y
= crtc_y
;
2154 plane_state
->crtc_w
= crtc_w
;
2155 plane_state
->crtc_h
= crtc_h
;
2156 plane_state
->src_x
= src_x
;
2157 plane_state
->src_y
= src_y
;
2158 plane_state
->src_w
= src_w
;
2159 plane_state
->src_h
= src_h
;
2161 if (plane
== crtc
->cursor
)
2162 state
->legacy_cursor_update
= true;
2164 ret
= drm_atomic_commit(state
);
2166 drm_atomic_state_put(state
);
2169 EXPORT_SYMBOL(drm_atomic_helper_update_plane
);
2172 * drm_atomic_helper_disable_plane - Helper for primary plane disable using * atomic
2173 * @plane: plane to disable
2174 * @ctx: lock acquire context
2176 * Provides a default plane disable handler using the atomic driver interface.
2179 * Zero on success, error code on failure
2181 int drm_atomic_helper_disable_plane(struct drm_plane
*plane
,
2182 struct drm_modeset_acquire_ctx
*ctx
)
2184 struct drm_atomic_state
*state
;
2185 struct drm_plane_state
*plane_state
;
2188 state
= drm_atomic_state_alloc(plane
->dev
);
2192 state
->acquire_ctx
= ctx
;
2193 plane_state
= drm_atomic_get_plane_state(state
, plane
);
2194 if (IS_ERR(plane_state
)) {
2195 ret
= PTR_ERR(plane_state
);
2199 if (plane_state
->crtc
&& (plane
== plane
->crtc
->cursor
))
2200 plane_state
->state
->legacy_cursor_update
= true;
2202 ret
= __drm_atomic_helper_disable_plane(plane
, plane_state
);
2206 ret
= drm_atomic_commit(state
);
2208 drm_atomic_state_put(state
);
2211 EXPORT_SYMBOL(drm_atomic_helper_disable_plane
);
2213 /* just used from fb-helper and atomic-helper: */
2214 int __drm_atomic_helper_disable_plane(struct drm_plane
*plane
,
2215 struct drm_plane_state
*plane_state
)
2219 ret
= drm_atomic_set_crtc_for_plane(plane_state
, NULL
);
2223 drm_atomic_set_fb_for_plane(plane_state
, NULL
);
2224 plane_state
->crtc_x
= 0;
2225 plane_state
->crtc_y
= 0;
2226 plane_state
->crtc_w
= 0;
2227 plane_state
->crtc_h
= 0;
2228 plane_state
->src_x
= 0;
2229 plane_state
->src_y
= 0;
2230 plane_state
->src_w
= 0;
2231 plane_state
->src_h
= 0;
2236 static int update_output_state(struct drm_atomic_state
*state
,
2237 struct drm_mode_set
*set
)
2239 struct drm_device
*dev
= set
->crtc
->dev
;
2240 struct drm_crtc
*crtc
;
2241 struct drm_crtc_state
*new_crtc_state
;
2242 struct drm_connector
*connector
;
2243 struct drm_connector_state
*new_conn_state
;
2246 ret
= drm_modeset_lock(&dev
->mode_config
.connection_mutex
,
2247 state
->acquire_ctx
);
2251 /* First disable all connectors on the target crtc. */
2252 ret
= drm_atomic_add_affected_connectors(state
, set
->crtc
);
2256 for_each_new_connector_in_state(state
, connector
, new_conn_state
, i
) {
2257 if (new_conn_state
->crtc
== set
->crtc
) {
2258 ret
= drm_atomic_set_crtc_for_connector(new_conn_state
,
2263 /* Make sure legacy setCrtc always re-trains */
2264 new_conn_state
->link_status
= DRM_LINK_STATUS_GOOD
;
2268 /* Then set all connectors from set->connectors on the target crtc */
2269 for (i
= 0; i
< set
->num_connectors
; i
++) {
2270 new_conn_state
= drm_atomic_get_connector_state(state
,
2271 set
->connectors
[i
]);
2272 if (IS_ERR(new_conn_state
))
2273 return PTR_ERR(new_conn_state
);
2275 ret
= drm_atomic_set_crtc_for_connector(new_conn_state
,
2281 for_each_new_crtc_in_state(state
, crtc
, new_crtc_state
, i
) {
2282 /* Don't update ->enable for the CRTC in the set_config request,
2283 * since a mismatch would indicate a bug in the upper layers.
2284 * The actual modeset code later on will catch any
2285 * inconsistencies here. */
2286 if (crtc
== set
->crtc
)
2289 if (!new_crtc_state
->connector_mask
) {
2290 ret
= drm_atomic_set_mode_prop_for_crtc(new_crtc_state
,
2295 new_crtc_state
->active
= false;
2303 * drm_atomic_helper_set_config - set a new config from userspace
2304 * @set: mode set configuration
2305 * @ctx: lock acquisition context
2307 * Provides a default crtc set_config handler using the atomic driver interface.
2309 * NOTE: For backwards compatibility with old userspace this automatically
2310 * resets the "link-status" property to GOOD, to force any link
2311 * re-training. The SETCRTC ioctl does not define whether an update does
2312 * need a full modeset or just a plane update, hence we're allowed to do
2313 * that. See also drm_mode_connector_set_link_status_property().
2316 * Returns 0 on success, negative errno numbers on failure.
2318 int drm_atomic_helper_set_config(struct drm_mode_set
*set
,
2319 struct drm_modeset_acquire_ctx
*ctx
)
2321 struct drm_atomic_state
*state
;
2322 struct drm_crtc
*crtc
= set
->crtc
;
2325 state
= drm_atomic_state_alloc(crtc
->dev
);
2329 state
->acquire_ctx
= ctx
;
2330 ret
= __drm_atomic_helper_set_config(set
, state
);
2334 ret
= handle_conflicting_encoders(state
, true);
2338 ret
= drm_atomic_commit(state
);
2341 drm_atomic_state_put(state
);
2344 EXPORT_SYMBOL(drm_atomic_helper_set_config
);
2346 /* just used from fb-helper and atomic-helper: */
2347 int __drm_atomic_helper_set_config(struct drm_mode_set
*set
,
2348 struct drm_atomic_state
*state
)
2350 struct drm_crtc_state
*crtc_state
;
2351 struct drm_plane_state
*primary_state
;
2352 struct drm_crtc
*crtc
= set
->crtc
;
2353 int hdisplay
, vdisplay
;
2356 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
2357 if (IS_ERR(crtc_state
))
2358 return PTR_ERR(crtc_state
);
2360 primary_state
= drm_atomic_get_plane_state(state
, crtc
->primary
);
2361 if (IS_ERR(primary_state
))
2362 return PTR_ERR(primary_state
);
2366 WARN_ON(set
->num_connectors
);
2368 ret
= drm_atomic_set_mode_for_crtc(crtc_state
, NULL
);
2372 crtc_state
->active
= false;
2374 ret
= drm_atomic_set_crtc_for_plane(primary_state
, NULL
);
2378 drm_atomic_set_fb_for_plane(primary_state
, NULL
);
2384 WARN_ON(!set
->num_connectors
);
2386 ret
= drm_atomic_set_mode_for_crtc(crtc_state
, set
->mode
);
2390 crtc_state
->active
= true;
2392 ret
= drm_atomic_set_crtc_for_plane(primary_state
, crtc
);
2396 drm_mode_get_hv_timing(set
->mode
, &hdisplay
, &vdisplay
);
2398 drm_atomic_set_fb_for_plane(primary_state
, set
->fb
);
2399 primary_state
->crtc_x
= 0;
2400 primary_state
->crtc_y
= 0;
2401 primary_state
->crtc_w
= hdisplay
;
2402 primary_state
->crtc_h
= vdisplay
;
2403 primary_state
->src_x
= set
->x
<< 16;
2404 primary_state
->src_y
= set
->y
<< 16;
2405 if (drm_rotation_90_or_270(primary_state
->rotation
)) {
2406 primary_state
->src_w
= vdisplay
<< 16;
2407 primary_state
->src_h
= hdisplay
<< 16;
2409 primary_state
->src_w
= hdisplay
<< 16;
2410 primary_state
->src_h
= vdisplay
<< 16;
2414 ret
= update_output_state(state
, set
);
2422 * drm_atomic_helper_disable_all - disable all currently active outputs
2424 * @ctx: lock acquisition context
2426 * Loops through all connectors, finding those that aren't turned off and then
2427 * turns them off by setting their DPMS mode to OFF and deactivating the CRTC
2428 * that they are connected to.
2430 * This is used for example in suspend/resume to disable all currently active
2431 * functions when suspending. If you just want to shut down everything at e.g.
2432 * driver unload, look at drm_atomic_helper_shutdown().
2434 * Note that if callers haven't already acquired all modeset locks this might
2435 * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
2438 * 0 on success or a negative error code on failure.
2441 * drm_atomic_helper_suspend(), drm_atomic_helper_resume() and
2442 * drm_atomic_helper_shutdown().
2444 int drm_atomic_helper_disable_all(struct drm_device
*dev
,
2445 struct drm_modeset_acquire_ctx
*ctx
)
2447 struct drm_atomic_state
*state
;
2448 struct drm_connector_state
*conn_state
;
2449 struct drm_connector
*conn
;
2450 struct drm_plane_state
*plane_state
;
2451 struct drm_plane
*plane
;
2452 struct drm_crtc_state
*crtc_state
;
2453 struct drm_crtc
*crtc
;
2456 state
= drm_atomic_state_alloc(dev
);
2460 state
->acquire_ctx
= ctx
;
2462 drm_for_each_crtc(crtc
, dev
) {
2463 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
2464 if (IS_ERR(crtc_state
)) {
2465 ret
= PTR_ERR(crtc_state
);
2469 crtc_state
->active
= false;
2471 ret
= drm_atomic_set_mode_prop_for_crtc(crtc_state
, NULL
);
2475 ret
= drm_atomic_add_affected_planes(state
, crtc
);
2479 ret
= drm_atomic_add_affected_connectors(state
, crtc
);
2484 for_each_connector_in_state(state
, conn
, conn_state
, i
) {
2485 ret
= drm_atomic_set_crtc_for_connector(conn_state
, NULL
);
2490 for_each_plane_in_state(state
, plane
, plane_state
, i
) {
2491 ret
= drm_atomic_set_crtc_for_plane(plane_state
, NULL
);
2495 drm_atomic_set_fb_for_plane(plane_state
, NULL
);
2498 ret
= drm_atomic_commit(state
);
2500 drm_atomic_state_put(state
);
2504 EXPORT_SYMBOL(drm_atomic_helper_disable_all
);
2507 * drm_atomic_helper_shutdown - shutdown all CRTC
2510 * This shuts down all CRTC, which is useful for driver unloading. Shutdown on
2511 * suspend should instead be handled with drm_atomic_helper_suspend(), since
2512 * that also takes a snapshot of the modeset state to be restored on resume.
2514 * This is just a convenience wrapper around drm_atomic_helper_disable_all(),
2515 * and it is the atomic version of drm_crtc_force_disable_all().
2517 void drm_atomic_helper_shutdown(struct drm_device
*dev
)
2519 struct drm_modeset_acquire_ctx ctx
;
2522 drm_modeset_acquire_init(&ctx
, 0);
2524 ret
= drm_modeset_lock_all_ctx(dev
, &ctx
);
2526 ret
= drm_atomic_helper_disable_all(dev
, &ctx
);
2528 if (ret
!= -EDEADLK
)
2531 drm_modeset_backoff(&ctx
);
2535 DRM_ERROR("Disabling all crtc's during unload failed with %i\n", ret
);
2537 drm_modeset_drop_locks(&ctx
);
2538 drm_modeset_acquire_fini(&ctx
);
2540 EXPORT_SYMBOL(drm_atomic_helper_shutdown
);
2543 * drm_atomic_helper_suspend - subsystem-level suspend helper
2546 * Duplicates the current atomic state, disables all active outputs and then
2547 * returns a pointer to the original atomic state to the caller. Drivers can
2548 * pass this pointer to the drm_atomic_helper_resume() helper upon resume to
2549 * restore the output configuration that was active at the time the system
2552 * Note that it is potentially unsafe to use this. The atomic state object
2553 * returned by this function is assumed to be persistent. Drivers must ensure
2554 * that this holds true. Before calling this function, drivers must make sure
2555 * to suspend fbdev emulation so that nothing can be using the device.
2558 * A pointer to a copy of the state before suspend on success or an ERR_PTR()-
2559 * encoded error code on failure. Drivers should store the returned atomic
2560 * state object and pass it to the drm_atomic_helper_resume() helper upon
2564 * drm_atomic_helper_duplicate_state(), drm_atomic_helper_disable_all(),
2565 * drm_atomic_helper_resume(), drm_atomic_helper_commit_duplicated_state()
2567 struct drm_atomic_state
*drm_atomic_helper_suspend(struct drm_device
*dev
)
2569 struct drm_modeset_acquire_ctx ctx
;
2570 struct drm_atomic_state
*state
;
2573 drm_modeset_acquire_init(&ctx
, 0);
2576 err
= drm_modeset_lock_all_ctx(dev
, &ctx
);
2578 state
= ERR_PTR(err
);
2582 state
= drm_atomic_helper_duplicate_state(dev
, &ctx
);
2586 err
= drm_atomic_helper_disable_all(dev
, &ctx
);
2588 drm_atomic_state_put(state
);
2589 state
= ERR_PTR(err
);
2594 if (PTR_ERR(state
) == -EDEADLK
) {
2595 drm_modeset_backoff(&ctx
);
2599 drm_modeset_drop_locks(&ctx
);
2600 drm_modeset_acquire_fini(&ctx
);
2603 EXPORT_SYMBOL(drm_atomic_helper_suspend
);
2606 * drm_atomic_helper_commit_duplicated_state - commit duplicated state
2607 * @state: duplicated atomic state to commit
2608 * @ctx: pointer to acquire_ctx to use for commit.
2610 * The state returned by drm_atomic_helper_duplicate_state() and
2611 * drm_atomic_helper_suspend() is partially invalid, and needs to
2612 * be fixed up before commit.
2615 * 0 on success or a negative error code on failure.
2618 * drm_atomic_helper_suspend()
2620 int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state
*state
,
2621 struct drm_modeset_acquire_ctx
*ctx
)
2624 struct drm_plane
*plane
;
2625 struct drm_plane_state
*new_plane_state
;
2626 struct drm_connector
*connector
;
2627 struct drm_connector_state
*new_conn_state
;
2628 struct drm_crtc
*crtc
;
2629 struct drm_crtc_state
*new_crtc_state
;
2631 state
->acquire_ctx
= ctx
;
2633 for_each_new_plane_in_state(state
, plane
, new_plane_state
, i
)
2634 state
->planes
[i
].old_state
= plane
->state
;
2636 for_each_new_crtc_in_state(state
, crtc
, new_crtc_state
, i
)
2637 state
->crtcs
[i
].old_state
= crtc
->state
;
2639 for_each_new_connector_in_state(state
, connector
, new_conn_state
, i
)
2640 state
->connectors
[i
].old_state
= connector
->state
;
2642 return drm_atomic_commit(state
);
2644 EXPORT_SYMBOL(drm_atomic_helper_commit_duplicated_state
);
2647 * drm_atomic_helper_resume - subsystem-level resume helper
2649 * @state: atomic state to resume to
2651 * Calls drm_mode_config_reset() to synchronize hardware and software states,
2652 * grabs all modeset locks and commits the atomic state object. This can be
2653 * used in conjunction with the drm_atomic_helper_suspend() helper to
2654 * implement suspend/resume for drivers that support atomic mode-setting.
2657 * 0 on success or a negative error code on failure.
2660 * drm_atomic_helper_suspend()
2662 int drm_atomic_helper_resume(struct drm_device
*dev
,
2663 struct drm_atomic_state
*state
)
2665 struct drm_modeset_acquire_ctx ctx
;
2668 drm_mode_config_reset(dev
);
2670 drm_modeset_acquire_init(&ctx
, 0);
2672 err
= drm_modeset_lock_all_ctx(dev
, &ctx
);
2676 err
= drm_atomic_helper_commit_duplicated_state(state
, &ctx
);
2678 if (err
!= -EDEADLK
)
2681 drm_modeset_backoff(&ctx
);
2684 drm_modeset_drop_locks(&ctx
);
2685 drm_modeset_acquire_fini(&ctx
);
2689 EXPORT_SYMBOL(drm_atomic_helper_resume
);
2692 * drm_atomic_helper_crtc_set_property - helper for crtc properties
2694 * @property: DRM property
2695 * @val: value of property
2697 * Provides a default crtc set_property handler using the atomic driver
2701 * Zero on success, error code on failure
2704 drm_atomic_helper_crtc_set_property(struct drm_crtc
*crtc
,
2705 struct drm_property
*property
,
2708 struct drm_atomic_state
*state
;
2709 struct drm_crtc_state
*crtc_state
;
2712 state
= drm_atomic_state_alloc(crtc
->dev
);
2716 /* ->set_property is always called with all locks held. */
2717 state
->acquire_ctx
= crtc
->dev
->mode_config
.acquire_ctx
;
2719 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
2720 if (IS_ERR(crtc_state
)) {
2721 ret
= PTR_ERR(crtc_state
);
2725 ret
= drm_atomic_crtc_set_property(crtc
, crtc_state
,
2730 ret
= drm_atomic_commit(state
);
2732 if (ret
== -EDEADLK
)
2735 drm_atomic_state_put(state
);
2739 drm_atomic_state_clear(state
);
2740 drm_atomic_legacy_backoff(state
);
2744 EXPORT_SYMBOL(drm_atomic_helper_crtc_set_property
);
2747 * drm_atomic_helper_plane_set_property - helper for plane properties
2749 * @property: DRM property
2750 * @val: value of property
2752 * Provides a default plane set_property handler using the atomic driver
2756 * Zero on success, error code on failure
2759 drm_atomic_helper_plane_set_property(struct drm_plane
*plane
,
2760 struct drm_property
*property
,
2763 struct drm_atomic_state
*state
;
2764 struct drm_plane_state
*plane_state
;
2767 state
= drm_atomic_state_alloc(plane
->dev
);
2771 /* ->set_property is always called with all locks held. */
2772 state
->acquire_ctx
= plane
->dev
->mode_config
.acquire_ctx
;
2774 plane_state
= drm_atomic_get_plane_state(state
, plane
);
2775 if (IS_ERR(plane_state
)) {
2776 ret
= PTR_ERR(plane_state
);
2780 ret
= drm_atomic_plane_set_property(plane
, plane_state
,
2785 ret
= drm_atomic_commit(state
);
2787 if (ret
== -EDEADLK
)
2790 drm_atomic_state_put(state
);
2794 drm_atomic_state_clear(state
);
2795 drm_atomic_legacy_backoff(state
);
2799 EXPORT_SYMBOL(drm_atomic_helper_plane_set_property
);
2802 * drm_atomic_helper_connector_set_property - helper for connector properties
2803 * @connector: DRM connector
2804 * @property: DRM property
2805 * @val: value of property
2807 * Provides a default connector set_property handler using the atomic driver
2811 * Zero on success, error code on failure
2814 drm_atomic_helper_connector_set_property(struct drm_connector
*connector
,
2815 struct drm_property
*property
,
2818 struct drm_atomic_state
*state
;
2819 struct drm_connector_state
*connector_state
;
2822 state
= drm_atomic_state_alloc(connector
->dev
);
2826 /* ->set_property is always called with all locks held. */
2827 state
->acquire_ctx
= connector
->dev
->mode_config
.acquire_ctx
;
2829 connector_state
= drm_atomic_get_connector_state(state
, connector
);
2830 if (IS_ERR(connector_state
)) {
2831 ret
= PTR_ERR(connector_state
);
2835 ret
= drm_atomic_connector_set_property(connector
, connector_state
,
2840 ret
= drm_atomic_commit(state
);
2842 if (ret
== -EDEADLK
)
2845 drm_atomic_state_put(state
);
2849 drm_atomic_state_clear(state
);
2850 drm_atomic_legacy_backoff(state
);
2854 EXPORT_SYMBOL(drm_atomic_helper_connector_set_property
);
2856 static int page_flip_common(
2857 struct drm_atomic_state
*state
,
2858 struct drm_crtc
*crtc
,
2859 struct drm_framebuffer
*fb
,
2860 struct drm_pending_vblank_event
*event
,
2863 struct drm_plane
*plane
= crtc
->primary
;
2864 struct drm_plane_state
*plane_state
;
2865 struct drm_crtc_state
*crtc_state
;
2868 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
2869 if (IS_ERR(crtc_state
))
2870 return PTR_ERR(crtc_state
);
2872 crtc_state
->event
= event
;
2873 crtc_state
->pageflip_flags
= flags
;
2875 plane_state
= drm_atomic_get_plane_state(state
, plane
);
2876 if (IS_ERR(plane_state
))
2877 return PTR_ERR(plane_state
);
2879 ret
= drm_atomic_set_crtc_for_plane(plane_state
, crtc
);
2882 drm_atomic_set_fb_for_plane(plane_state
, fb
);
2884 /* Make sure we don't accidentally do a full modeset. */
2885 state
->allow_modeset
= false;
2886 if (!crtc_state
->active
) {
2887 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled, rejecting legacy flip\n",
2888 crtc
->base
.id
, crtc
->name
);
2896 * drm_atomic_helper_page_flip - execute a legacy page flip
2898 * @fb: DRM framebuffer
2899 * @event: optional DRM event to signal upon completion
2900 * @flags: flip flags for non-vblank sync'ed updates
2901 * @ctx: lock acquisition context
2903 * Provides a default &drm_crtc_funcs.page_flip implementation
2904 * using the atomic driver interface.
2907 * Returns 0 on success, negative errno numbers on failure.
2910 * drm_atomic_helper_page_flip_target()
2912 int drm_atomic_helper_page_flip(struct drm_crtc
*crtc
,
2913 struct drm_framebuffer
*fb
,
2914 struct drm_pending_vblank_event
*event
,
2916 struct drm_modeset_acquire_ctx
*ctx
)
2918 struct drm_plane
*plane
= crtc
->primary
;
2919 struct drm_atomic_state
*state
;
2922 state
= drm_atomic_state_alloc(plane
->dev
);
2926 state
->acquire_ctx
= ctx
;
2928 ret
= page_flip_common(state
, crtc
, fb
, event
, flags
);
2932 ret
= drm_atomic_nonblocking_commit(state
);
2934 drm_atomic_state_put(state
);
2937 EXPORT_SYMBOL(drm_atomic_helper_page_flip
);
2940 * drm_atomic_helper_page_flip_target - do page flip on target vblank period.
2942 * @fb: DRM framebuffer
2943 * @event: optional DRM event to signal upon completion
2944 * @flags: flip flags for non-vblank sync'ed updates
2945 * @target: specifying the target vblank period when the flip to take effect
2946 * @ctx: lock acquisition context
2948 * Provides a default &drm_crtc_funcs.page_flip_target implementation.
2949 * Similar to drm_atomic_helper_page_flip() with extra parameter to specify
2950 * target vblank period to flip.
2953 * Returns 0 on success, negative errno numbers on failure.
2955 int drm_atomic_helper_page_flip_target(
2956 struct drm_crtc
*crtc
,
2957 struct drm_framebuffer
*fb
,
2958 struct drm_pending_vblank_event
*event
,
2961 struct drm_modeset_acquire_ctx
*ctx
)
2963 struct drm_plane
*plane
= crtc
->primary
;
2964 struct drm_atomic_state
*state
;
2965 struct drm_crtc_state
*crtc_state
;
2968 state
= drm_atomic_state_alloc(plane
->dev
);
2972 state
->acquire_ctx
= ctx
;
2974 ret
= page_flip_common(state
, crtc
, fb
, event
, flags
);
2978 crtc_state
= drm_atomic_get_new_crtc_state(state
, crtc
);
2979 if (WARN_ON(!crtc_state
)) {
2983 crtc_state
->target_vblank
= target
;
2985 ret
= drm_atomic_nonblocking_commit(state
);
2987 drm_atomic_state_put(state
);
2990 EXPORT_SYMBOL(drm_atomic_helper_page_flip_target
);
2993 * drm_atomic_helper_connector_dpms() - connector dpms helper implementation
2994 * @connector: affected connector
2997 * This is the main helper function provided by the atomic helper framework for
2998 * implementing the legacy DPMS connector interface. It computes the new desired
2999 * &drm_crtc_state.active state for the corresponding CRTC (if the connector is
3000 * enabled) and updates it.
3003 * Returns 0 on success, negative errno numbers on failure.
3005 int drm_atomic_helper_connector_dpms(struct drm_connector
*connector
,
3008 struct drm_mode_config
*config
= &connector
->dev
->mode_config
;
3009 struct drm_atomic_state
*state
;
3010 struct drm_crtc_state
*crtc_state
;
3011 struct drm_crtc
*crtc
;
3012 struct drm_connector
*tmp_connector
;
3013 struct drm_connector_list_iter conn_iter
;
3015 bool active
= false;
3016 int old_mode
= connector
->dpms
;
3018 if (mode
!= DRM_MODE_DPMS_ON
)
3019 mode
= DRM_MODE_DPMS_OFF
;
3021 connector
->dpms
= mode
;
3022 crtc
= connector
->state
->crtc
;
3027 state
= drm_atomic_state_alloc(connector
->dev
);
3031 state
->acquire_ctx
= crtc
->dev
->mode_config
.acquire_ctx
;
3033 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
3034 if (IS_ERR(crtc_state
)) {
3035 ret
= PTR_ERR(crtc_state
);
3039 WARN_ON(!drm_modeset_is_locked(&config
->connection_mutex
));
3041 drm_connector_list_iter_begin(connector
->dev
, &conn_iter
);
3042 drm_for_each_connector_iter(tmp_connector
, &conn_iter
) {
3043 if (tmp_connector
->state
->crtc
!= crtc
)
3046 if (tmp_connector
->dpms
== DRM_MODE_DPMS_ON
) {
3051 drm_connector_list_iter_end(&conn_iter
);
3052 crtc_state
->active
= active
;
3054 ret
= drm_atomic_commit(state
);
3056 if (ret
== -EDEADLK
)
3059 connector
->dpms
= old_mode
;
3060 drm_atomic_state_put(state
);
3064 drm_atomic_state_clear(state
);
3065 drm_atomic_legacy_backoff(state
);
3069 EXPORT_SYMBOL(drm_atomic_helper_connector_dpms
);
3072 * drm_atomic_helper_best_encoder - Helper for
3073 * &drm_connector_helper_funcs.best_encoder callback
3074 * @connector: Connector control structure
3076 * This is a &drm_connector_helper_funcs.best_encoder callback helper for
3077 * connectors that support exactly 1 encoder, statically determined at driver
3080 struct drm_encoder
*
3081 drm_atomic_helper_best_encoder(struct drm_connector
*connector
)
3083 WARN_ON(connector
->encoder_ids
[1]);
3084 return drm_encoder_find(connector
->dev
, connector
->encoder_ids
[0]);
3086 EXPORT_SYMBOL(drm_atomic_helper_best_encoder
);
3089 * DOC: atomic state reset and initialization
3091 * Both the drm core and the atomic helpers assume that there is always the full
3092 * and correct atomic software state for all connectors, CRTCs and planes
3093 * available. Which is a bit a problem on driver load and also after system
3094 * suspend. One way to solve this is to have a hardware state read-out
3095 * infrastructure which reconstructs the full software state (e.g. the i915
3098 * The simpler solution is to just reset the software state to everything off,
3099 * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
3100 * the atomic helpers provide default reset implementations for all hooks.
3102 * On the upside the precise state tracking of atomic simplifies system suspend
3103 * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe
3104 * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume().
3105 * For other drivers the building blocks are split out, see the documentation
3106 * for these functions.
3110 * drm_atomic_helper_crtc_reset - default &drm_crtc_funcs.reset hook for CRTCs
3113 * Resets the atomic state for @crtc by freeing the state pointer (which might
3114 * be NULL, e.g. at driver load time) and allocating a new empty state object.
3116 void drm_atomic_helper_crtc_reset(struct drm_crtc
*crtc
)
3119 __drm_atomic_helper_crtc_destroy_state(crtc
->state
);
3122 crtc
->state
= kzalloc(sizeof(*crtc
->state
), GFP_KERNEL
);
3125 crtc
->state
->crtc
= crtc
;
3127 EXPORT_SYMBOL(drm_atomic_helper_crtc_reset
);
3130 * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
3131 * @crtc: CRTC object
3132 * @state: atomic CRTC state
3134 * Copies atomic state from a CRTC's current state and resets inferred values.
3135 * This is useful for drivers that subclass the CRTC state.
3137 void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc
*crtc
,
3138 struct drm_crtc_state
*state
)
3140 memcpy(state
, crtc
->state
, sizeof(*state
));
3142 if (state
->mode_blob
)
3143 drm_property_blob_get(state
->mode_blob
);
3144 if (state
->degamma_lut
)
3145 drm_property_blob_get(state
->degamma_lut
);
3147 drm_property_blob_get(state
->ctm
);
3148 if (state
->gamma_lut
)
3149 drm_property_blob_get(state
->gamma_lut
);
3150 state
->mode_changed
= false;
3151 state
->active_changed
= false;
3152 state
->planes_changed
= false;
3153 state
->connectors_changed
= false;
3154 state
->color_mgmt_changed
= false;
3155 state
->zpos_changed
= false;
3156 state
->event
= NULL
;
3157 state
->pageflip_flags
= 0;
3159 EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state
);
3162 * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
3165 * Default CRTC state duplicate hook for drivers which don't have their own
3166 * subclassed CRTC state structure.
3168 struct drm_crtc_state
*
3169 drm_atomic_helper_crtc_duplicate_state(struct drm_crtc
*crtc
)
3171 struct drm_crtc_state
*state
;
3173 if (WARN_ON(!crtc
->state
))
3176 state
= kmalloc(sizeof(*state
), GFP_KERNEL
);
3178 __drm_atomic_helper_crtc_duplicate_state(crtc
, state
);
3182 EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state
);
3185 * __drm_atomic_helper_crtc_destroy_state - release CRTC state
3186 * @state: CRTC state object to release
3188 * Releases all resources stored in the CRTC state without actually freeing
3189 * the memory of the CRTC state. This is useful for drivers that subclass the
3192 void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state
*state
)
3194 drm_property_blob_put(state
->mode_blob
);
3195 drm_property_blob_put(state
->degamma_lut
);
3196 drm_property_blob_put(state
->ctm
);
3197 drm_property_blob_put(state
->gamma_lut
);
3199 EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state
);
3202 * drm_atomic_helper_crtc_destroy_state - default state destroy hook
3204 * @state: CRTC state object to release
3206 * Default CRTC state destroy hook for drivers which don't have their own
3207 * subclassed CRTC state structure.
3209 void drm_atomic_helper_crtc_destroy_state(struct drm_crtc
*crtc
,
3210 struct drm_crtc_state
*state
)
3212 __drm_atomic_helper_crtc_destroy_state(state
);
3215 EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state
);
3218 * drm_atomic_helper_plane_reset - default &drm_plane_funcs.reset hook for planes
3221 * Resets the atomic state for @plane by freeing the state pointer (which might
3222 * be NULL, e.g. at driver load time) and allocating a new empty state object.
3224 void drm_atomic_helper_plane_reset(struct drm_plane
*plane
)
3227 __drm_atomic_helper_plane_destroy_state(plane
->state
);
3229 kfree(plane
->state
);
3230 plane
->state
= kzalloc(sizeof(*plane
->state
), GFP_KERNEL
);
3233 plane
->state
->plane
= plane
;
3234 plane
->state
->rotation
= DRM_ROTATE_0
;
3237 EXPORT_SYMBOL(drm_atomic_helper_plane_reset
);
3240 * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state
3241 * @plane: plane object
3242 * @state: atomic plane state
3244 * Copies atomic state from a plane's current state. This is useful for
3245 * drivers that subclass the plane state.
3247 void __drm_atomic_helper_plane_duplicate_state(struct drm_plane
*plane
,
3248 struct drm_plane_state
*state
)
3250 memcpy(state
, plane
->state
, sizeof(*state
));
3253 drm_framebuffer_get(state
->fb
);
3255 state
->fence
= NULL
;
3257 EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state
);
3260 * drm_atomic_helper_plane_duplicate_state - default state duplicate hook
3263 * Default plane state duplicate hook for drivers which don't have their own
3264 * subclassed plane state structure.
3266 struct drm_plane_state
*
3267 drm_atomic_helper_plane_duplicate_state(struct drm_plane
*plane
)
3269 struct drm_plane_state
*state
;
3271 if (WARN_ON(!plane
->state
))
3274 state
= kmalloc(sizeof(*state
), GFP_KERNEL
);
3276 __drm_atomic_helper_plane_duplicate_state(plane
, state
);
3280 EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state
);
3283 * __drm_atomic_helper_plane_destroy_state - release plane state
3284 * @state: plane state object to release
3286 * Releases all resources stored in the plane state without actually freeing
3287 * the memory of the plane state. This is useful for drivers that subclass the
3290 void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state
*state
)
3293 drm_framebuffer_put(state
->fb
);
3296 dma_fence_put(state
->fence
);
3298 EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state
);
3301 * drm_atomic_helper_plane_destroy_state - default state destroy hook
3303 * @state: plane state object to release
3305 * Default plane state destroy hook for drivers which don't have their own
3306 * subclassed plane state structure.
3308 void drm_atomic_helper_plane_destroy_state(struct drm_plane
*plane
,
3309 struct drm_plane_state
*state
)
3311 __drm_atomic_helper_plane_destroy_state(state
);
3314 EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state
);
3317 * __drm_atomic_helper_connector_reset - reset state on connector
3318 * @connector: drm connector
3319 * @conn_state: connector state to assign
3321 * Initializes the newly allocated @conn_state and assigns it to
3322 * the &drm_conector->state pointer of @connector, usually required when
3323 * initializing the drivers or when called from the &drm_connector_funcs.reset
3326 * This is useful for drivers that subclass the connector state.
3329 __drm_atomic_helper_connector_reset(struct drm_connector
*connector
,
3330 struct drm_connector_state
*conn_state
)
3333 conn_state
->connector
= connector
;
3335 connector
->state
= conn_state
;
3337 EXPORT_SYMBOL(__drm_atomic_helper_connector_reset
);
3340 * drm_atomic_helper_connector_reset - default &drm_connector_funcs.reset hook for connectors
3341 * @connector: drm connector
3343 * Resets the atomic state for @connector by freeing the state pointer (which
3344 * might be NULL, e.g. at driver load time) and allocating a new empty state
3347 void drm_atomic_helper_connector_reset(struct drm_connector
*connector
)
3349 struct drm_connector_state
*conn_state
=
3350 kzalloc(sizeof(*conn_state
), GFP_KERNEL
);
3352 if (connector
->state
)
3353 __drm_atomic_helper_connector_destroy_state(connector
->state
);
3355 kfree(connector
->state
);
3356 __drm_atomic_helper_connector_reset(connector
, conn_state
);
3358 EXPORT_SYMBOL(drm_atomic_helper_connector_reset
);
3361 * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state
3362 * @connector: connector object
3363 * @state: atomic connector state
3365 * Copies atomic state from a connector's current state. This is useful for
3366 * drivers that subclass the connector state.
3369 __drm_atomic_helper_connector_duplicate_state(struct drm_connector
*connector
,
3370 struct drm_connector_state
*state
)
3372 memcpy(state
, connector
->state
, sizeof(*state
));
3374 drm_connector_get(connector
);
3376 EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state
);
3379 * drm_atomic_helper_connector_duplicate_state - default state duplicate hook
3380 * @connector: drm connector
3382 * Default connector state duplicate hook for drivers which don't have their own
3383 * subclassed connector state structure.
3385 struct drm_connector_state
*
3386 drm_atomic_helper_connector_duplicate_state(struct drm_connector
*connector
)
3388 struct drm_connector_state
*state
;
3390 if (WARN_ON(!connector
->state
))
3393 state
= kmalloc(sizeof(*state
), GFP_KERNEL
);
3395 __drm_atomic_helper_connector_duplicate_state(connector
, state
);
3399 EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state
);
3402 * drm_atomic_helper_duplicate_state - duplicate an atomic state object
3404 * @ctx: lock acquisition context
3406 * Makes a copy of the current atomic state by looping over all objects and
3407 * duplicating their respective states. This is used for example by suspend/
3408 * resume support code to save the state prior to suspend such that it can
3409 * be restored upon resume.
3411 * Note that this treats atomic state as persistent between save and restore.
3412 * Drivers must make sure that this is possible and won't result in confusion
3413 * or erroneous behaviour.
3415 * Note that if callers haven't already acquired all modeset locks this might
3416 * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
3419 * A pointer to the copy of the atomic state object on success or an
3420 * ERR_PTR()-encoded error code on failure.
3423 * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
3425 struct drm_atomic_state
*
3426 drm_atomic_helper_duplicate_state(struct drm_device
*dev
,
3427 struct drm_modeset_acquire_ctx
*ctx
)
3429 struct drm_atomic_state
*state
;
3430 struct drm_connector
*conn
;
3431 struct drm_connector_list_iter conn_iter
;
3432 struct drm_plane
*plane
;
3433 struct drm_crtc
*crtc
;
3436 state
= drm_atomic_state_alloc(dev
);
3438 return ERR_PTR(-ENOMEM
);
3440 state
->acquire_ctx
= ctx
;
3442 drm_for_each_crtc(crtc
, dev
) {
3443 struct drm_crtc_state
*crtc_state
;
3445 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
3446 if (IS_ERR(crtc_state
)) {
3447 err
= PTR_ERR(crtc_state
);
3452 drm_for_each_plane(plane
, dev
) {
3453 struct drm_plane_state
*plane_state
;
3455 plane_state
= drm_atomic_get_plane_state(state
, plane
);
3456 if (IS_ERR(plane_state
)) {
3457 err
= PTR_ERR(plane_state
);
3462 drm_connector_list_iter_begin(dev
, &conn_iter
);
3463 drm_for_each_connector_iter(conn
, &conn_iter
) {
3464 struct drm_connector_state
*conn_state
;
3466 conn_state
= drm_atomic_get_connector_state(state
, conn
);
3467 if (IS_ERR(conn_state
)) {
3468 err
= PTR_ERR(conn_state
);
3469 drm_connector_list_iter_end(&conn_iter
);
3473 drm_connector_list_iter_end(&conn_iter
);
3475 /* clear the acquire context so that it isn't accidentally reused */
3476 state
->acquire_ctx
= NULL
;
3480 drm_atomic_state_put(state
);
3481 state
= ERR_PTR(err
);
3486 EXPORT_SYMBOL(drm_atomic_helper_duplicate_state
);
3489 * __drm_atomic_helper_connector_destroy_state - release connector state
3490 * @state: connector state object to release
3492 * Releases all resources stored in the connector state without actually
3493 * freeing the memory of the connector state. This is useful for drivers that
3494 * subclass the connector state.
3497 __drm_atomic_helper_connector_destroy_state(struct drm_connector_state
*state
)
3500 drm_connector_put(state
->connector
);
3502 EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state
);
3505 * drm_atomic_helper_connector_destroy_state - default state destroy hook
3506 * @connector: drm connector
3507 * @state: connector state object to release
3509 * Default connector state destroy hook for drivers which don't have their own
3510 * subclassed connector state structure.
3512 void drm_atomic_helper_connector_destroy_state(struct drm_connector
*connector
,
3513 struct drm_connector_state
*state
)
3515 __drm_atomic_helper_connector_destroy_state(state
);
3518 EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state
);
3521 * drm_atomic_helper_legacy_gamma_set - set the legacy gamma correction table
3522 * @crtc: CRTC object
3523 * @red: red correction table
3524 * @green: green correction table
3525 * @blue: green correction table
3526 * @size: size of the tables
3527 * @ctx: lock acquire context
3529 * Implements support for legacy gamma correction table for drivers
3530 * that support color management through the DEGAMMA_LUT/GAMMA_LUT
3533 int drm_atomic_helper_legacy_gamma_set(struct drm_crtc
*crtc
,
3534 u16
*red
, u16
*green
, u16
*blue
,
3536 struct drm_modeset_acquire_ctx
*ctx
)
3538 struct drm_device
*dev
= crtc
->dev
;
3539 struct drm_mode_config
*config
= &dev
->mode_config
;
3540 struct drm_atomic_state
*state
;
3541 struct drm_crtc_state
*crtc_state
;
3542 struct drm_property_blob
*blob
= NULL
;
3543 struct drm_color_lut
*blob_data
;
3546 state
= drm_atomic_state_alloc(crtc
->dev
);
3550 blob
= drm_property_create_blob(dev
,
3551 sizeof(struct drm_color_lut
) * size
,
3554 ret
= PTR_ERR(blob
);
3559 /* Prepare GAMMA_LUT with the legacy values. */
3560 blob_data
= (struct drm_color_lut
*) blob
->data
;
3561 for (i
= 0; i
< size
; i
++) {
3562 blob_data
[i
].red
= red
[i
];
3563 blob_data
[i
].green
= green
[i
];
3564 blob_data
[i
].blue
= blue
[i
];
3567 state
->acquire_ctx
= ctx
;
3568 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
3569 if (IS_ERR(crtc_state
)) {
3570 ret
= PTR_ERR(crtc_state
);
3574 /* Reset DEGAMMA_LUT and CTM properties. */
3575 ret
= drm_atomic_crtc_set_property(crtc
, crtc_state
,
3576 config
->degamma_lut_property
, 0);
3580 ret
= drm_atomic_crtc_set_property(crtc
, crtc_state
,
3581 config
->ctm_property
, 0);
3585 ret
= drm_atomic_crtc_set_property(crtc
, crtc_state
,
3586 config
->gamma_lut_property
, blob
->base
.id
);
3590 ret
= drm_atomic_commit(state
);
3593 drm_atomic_state_put(state
);
3594 drm_property_blob_put(blob
);
3597 EXPORT_SYMBOL(drm_atomic_helper_legacy_gamma_set
);