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>
30 #include <drm/drm_atomic.h>
31 #include <drm/drm_plane_helper.h>
34 * drm_atomic_state_default_release -
35 * release memory initialized by drm_atomic_state_init
36 * @state: atomic state
38 * Free all the memory allocated by drm_atomic_state_init.
39 * This is useful for drivers that subclass the atomic state.
41 void drm_atomic_state_default_release(struct drm_atomic_state
*state
)
43 kfree(state
->connectors
);
44 kfree(state
->connector_states
);
46 kfree(state
->crtc_states
);
48 kfree(state
->plane_states
);
50 EXPORT_SYMBOL(drm_atomic_state_default_release
);
53 * drm_atomic_state_init - init new atomic state
55 * @state: atomic state
57 * Default implementation for filling in a new atomic state.
58 * This is useful for drivers that subclass the atomic state.
61 drm_atomic_state_init(struct drm_device
*dev
, struct drm_atomic_state
*state
)
63 /* TODO legacy paths should maybe do a better job about
64 * setting this appropriately?
66 state
->allow_modeset
= true;
68 state
->num_connector
= ACCESS_ONCE(dev
->mode_config
.num_connector
);
70 state
->crtcs
= kcalloc(dev
->mode_config
.num_crtc
,
71 sizeof(*state
->crtcs
), GFP_KERNEL
);
74 state
->crtc_states
= kcalloc(dev
->mode_config
.num_crtc
,
75 sizeof(*state
->crtc_states
), GFP_KERNEL
);
76 if (!state
->crtc_states
)
78 state
->planes
= kcalloc(dev
->mode_config
.num_total_plane
,
79 sizeof(*state
->planes
), GFP_KERNEL
);
82 state
->plane_states
= kcalloc(dev
->mode_config
.num_total_plane
,
83 sizeof(*state
->plane_states
), GFP_KERNEL
);
84 if (!state
->plane_states
)
86 state
->connectors
= kcalloc(state
->num_connector
,
87 sizeof(*state
->connectors
),
89 if (!state
->connectors
)
91 state
->connector_states
= kcalloc(state
->num_connector
,
92 sizeof(*state
->connector_states
),
94 if (!state
->connector_states
)
99 DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state
);
103 drm_atomic_state_default_release(state
);
106 EXPORT_SYMBOL(drm_atomic_state_init
);
109 * drm_atomic_state_alloc - allocate atomic state
112 * This allocates an empty atomic state to track updates.
114 struct drm_atomic_state
*
115 drm_atomic_state_alloc(struct drm_device
*dev
)
117 struct drm_mode_config
*config
= &dev
->mode_config
;
118 struct drm_atomic_state
*state
;
120 if (!config
->funcs
->atomic_state_alloc
) {
121 state
= kzalloc(sizeof(*state
), GFP_KERNEL
);
124 if (drm_atomic_state_init(dev
, state
) < 0) {
131 return config
->funcs
->atomic_state_alloc(dev
);
133 EXPORT_SYMBOL(drm_atomic_state_alloc
);
136 * drm_atomic_state_default_clear - clear base atomic state
137 * @state: atomic state
139 * Default implementation for clearing atomic state.
140 * This is useful for drivers that subclass the atomic state.
142 void drm_atomic_state_default_clear(struct drm_atomic_state
*state
)
144 struct drm_device
*dev
= state
->dev
;
145 struct drm_mode_config
*config
= &dev
->mode_config
;
148 DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state
);
150 for (i
= 0; i
< state
->num_connector
; i
++) {
151 struct drm_connector
*connector
= state
->connectors
[i
];
156 WARN_ON(!drm_modeset_is_locked(&config
->connection_mutex
));
158 connector
->funcs
->atomic_destroy_state(connector
,
159 state
->connector_states
[i
]);
160 state
->connectors
[i
] = NULL
;
161 state
->connector_states
[i
] = NULL
;
164 for (i
= 0; i
< config
->num_crtc
; i
++) {
165 struct drm_crtc
*crtc
= state
->crtcs
[i
];
170 crtc
->funcs
->atomic_destroy_state(crtc
,
171 state
->crtc_states
[i
]);
172 state
->crtcs
[i
] = NULL
;
173 state
->crtc_states
[i
] = NULL
;
176 for (i
= 0; i
< config
->num_total_plane
; i
++) {
177 struct drm_plane
*plane
= state
->planes
[i
];
182 plane
->funcs
->atomic_destroy_state(plane
,
183 state
->plane_states
[i
]);
184 state
->planes
[i
] = NULL
;
185 state
->plane_states
[i
] = NULL
;
188 EXPORT_SYMBOL(drm_atomic_state_default_clear
);
191 * drm_atomic_state_clear - clear state object
192 * @state: atomic state
194 * When the w/w mutex algorithm detects a deadlock we need to back off and drop
195 * all locks. So someone else could sneak in and change the current modeset
196 * configuration. Which means that all the state assembled in @state is no
197 * longer an atomic update to the current state, but to some arbitrary earlier
198 * state. Which could break assumptions the driver's ->atomic_check likely
201 * Hence we must clear all cached state and completely start over, using this
204 void drm_atomic_state_clear(struct drm_atomic_state
*state
)
206 struct drm_device
*dev
= state
->dev
;
207 struct drm_mode_config
*config
= &dev
->mode_config
;
209 if (config
->funcs
->atomic_state_clear
)
210 config
->funcs
->atomic_state_clear(state
);
212 drm_atomic_state_default_clear(state
);
214 EXPORT_SYMBOL(drm_atomic_state_clear
);
217 * drm_atomic_state_free - free all memory for an atomic state
218 * @state: atomic state to deallocate
220 * This frees all memory associated with an atomic state, including all the
221 * per-object state for planes, crtcs and connectors.
223 void drm_atomic_state_free(struct drm_atomic_state
*state
)
225 struct drm_device
*dev
;
226 struct drm_mode_config
*config
;
232 config
= &dev
->mode_config
;
234 drm_atomic_state_clear(state
);
236 DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state
);
238 if (config
->funcs
->atomic_state_free
) {
239 config
->funcs
->atomic_state_free(state
);
241 drm_atomic_state_default_release(state
);
245 EXPORT_SYMBOL(drm_atomic_state_free
);
248 * drm_atomic_get_crtc_state - get crtc state
249 * @state: global atomic state object
250 * @crtc: crtc to get state object for
252 * This function returns the crtc state for the given crtc, allocating it if
253 * needed. It will also grab the relevant crtc lock to make sure that the state
258 * Either the allocated state or the error code encoded into the pointer. When
259 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
260 * entire atomic sequence must be restarted. All other errors are fatal.
262 struct drm_crtc_state
*
263 drm_atomic_get_crtc_state(struct drm_atomic_state
*state
,
264 struct drm_crtc
*crtc
)
266 int ret
, index
= drm_crtc_index(crtc
);
267 struct drm_crtc_state
*crtc_state
;
269 crtc_state
= drm_atomic_get_existing_crtc_state(state
, crtc
);
273 ret
= drm_modeset_lock(&crtc
->mutex
, state
->acquire_ctx
);
277 crtc_state
= crtc
->funcs
->atomic_duplicate_state(crtc
);
279 return ERR_PTR(-ENOMEM
);
281 state
->crtc_states
[index
] = crtc_state
;
282 state
->crtcs
[index
] = crtc
;
283 crtc_state
->state
= state
;
285 DRM_DEBUG_ATOMIC("Added [CRTC:%d] %p state to %p\n",
286 crtc
->base
.id
, crtc_state
, state
);
290 EXPORT_SYMBOL(drm_atomic_get_crtc_state
);
293 * drm_atomic_set_mode_for_crtc - set mode for CRTC
294 * @state: the CRTC whose incoming state to update
295 * @mode: kernel-internal mode to use for the CRTC, or NULL to disable
297 * Set a mode (originating from the kernel) on the desired CRTC state. Does
298 * not change any other state properties, including enable, active, or
302 * Zero on success, error code on failure. Cannot return -EDEADLK.
304 int drm_atomic_set_mode_for_crtc(struct drm_crtc_state
*state
,
305 struct drm_display_mode
*mode
)
307 struct drm_mode_modeinfo umode
;
309 /* Early return for no change. */
310 if (mode
&& memcmp(&state
->mode
, mode
, sizeof(*mode
)) == 0)
313 if (state
->mode_blob
)
314 drm_property_unreference_blob(state
->mode_blob
);
315 state
->mode_blob
= NULL
;
318 drm_mode_convert_to_umode(&umode
, mode
);
320 drm_property_create_blob(state
->crtc
->dev
,
323 if (IS_ERR(state
->mode_blob
))
324 return PTR_ERR(state
->mode_blob
);
326 drm_mode_copy(&state
->mode
, mode
);
327 state
->enable
= true;
328 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
331 memset(&state
->mode
, 0, sizeof(state
->mode
));
332 state
->enable
= false;
333 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
339 EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc
);
342 * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC
343 * @state: the CRTC whose incoming state to update
344 * @blob: pointer to blob property to use for mode
346 * Set a mode (originating from a blob property) on the desired CRTC state.
347 * This function will take a reference on the blob property for the CRTC state,
348 * and release the reference held on the state's existing mode property, if any
352 * Zero on success, error code on failure. Cannot return -EDEADLK.
354 int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state
*state
,
355 struct drm_property_blob
*blob
)
357 if (blob
== state
->mode_blob
)
360 if (state
->mode_blob
)
361 drm_property_unreference_blob(state
->mode_blob
);
362 state
->mode_blob
= NULL
;
365 if (blob
->length
!= sizeof(struct drm_mode_modeinfo
) ||
366 drm_mode_convert_umode(&state
->mode
,
367 (const struct drm_mode_modeinfo
*)
371 state
->mode_blob
= drm_property_reference_blob(blob
);
372 state
->enable
= true;
373 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
374 state
->mode
.name
, state
);
376 memset(&state
->mode
, 0, sizeof(state
->mode
));
377 state
->enable
= false;
378 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
384 EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc
);
387 * drm_atomic_crtc_set_property - set property on CRTC
388 * @crtc: the drm CRTC to set a property on
389 * @state: the state object to update with the new property value
390 * @property: the property to set
391 * @val: the new property value
393 * Use this instead of calling crtc->atomic_set_property directly.
394 * This function handles generic/core properties and calls out to
395 * driver's ->atomic_set_property() for driver properties. To ensure
396 * consistent behavior you must call this function rather than the
397 * driver hook directly.
400 * Zero on success, error code on failure
402 int drm_atomic_crtc_set_property(struct drm_crtc
*crtc
,
403 struct drm_crtc_state
*state
, struct drm_property
*property
,
406 struct drm_device
*dev
= crtc
->dev
;
407 struct drm_mode_config
*config
= &dev
->mode_config
;
410 if (property
== config
->prop_active
)
412 else if (property
== config
->prop_mode_id
) {
413 struct drm_property_blob
*mode
=
414 drm_property_lookup_blob(dev
, val
);
415 ret
= drm_atomic_set_mode_prop_for_crtc(state
, mode
);
417 drm_property_unreference_blob(mode
);
420 else if (crtc
->funcs
->atomic_set_property
)
421 return crtc
->funcs
->atomic_set_property(crtc
, state
, property
, val
);
427 EXPORT_SYMBOL(drm_atomic_crtc_set_property
);
430 * This function handles generic/core properties and calls out to
431 * driver's ->atomic_get_property() for driver properties. To ensure
432 * consistent behavior you must call this function rather than the
433 * driver hook directly.
435 int drm_atomic_crtc_get_property(struct drm_crtc
*crtc
,
436 const struct drm_crtc_state
*state
,
437 struct drm_property
*property
, uint64_t *val
)
439 struct drm_device
*dev
= crtc
->dev
;
440 struct drm_mode_config
*config
= &dev
->mode_config
;
442 if (property
== config
->prop_active
)
443 *val
= state
->active
;
444 else if (property
== config
->prop_mode_id
)
445 *val
= (state
->mode_blob
) ? state
->mode_blob
->base
.id
: 0;
446 else if (crtc
->funcs
->atomic_get_property
)
447 return crtc
->funcs
->atomic_get_property(crtc
, state
, property
, val
);
455 * drm_atomic_crtc_check - check crtc state
456 * @crtc: crtc to check
457 * @state: crtc state to check
459 * Provides core sanity checks for crtc state.
462 * Zero on success, error code on failure
464 static int drm_atomic_crtc_check(struct drm_crtc
*crtc
,
465 struct drm_crtc_state
*state
)
467 /* NOTE: we explicitly don't enforce constraints such as primary
468 * layer covering entire screen, since that is something we want
469 * to allow (on hw that supports it). For hw that does not, it
470 * should be checked in driver's crtc->atomic_check() vfunc.
472 * TODO: Add generic modeset state checks once we support those.
475 if (state
->active
&& !state
->enable
) {
476 DRM_DEBUG_ATOMIC("[CRTC:%d] active without enabled\n",
481 /* The state->enable vs. state->mode_blob checks can be WARN_ON,
482 * as this is a kernel-internal detail that userspace should never
483 * be able to trigger. */
484 if (drm_core_check_feature(crtc
->dev
, DRIVER_ATOMIC
) &&
485 WARN_ON(state
->enable
&& !state
->mode_blob
)) {
486 DRM_DEBUG_ATOMIC("[CRTC:%d] enabled without mode blob\n",
491 if (drm_core_check_feature(crtc
->dev
, DRIVER_ATOMIC
) &&
492 WARN_ON(!state
->enable
&& state
->mode_blob
)) {
493 DRM_DEBUG_ATOMIC("[CRTC:%d] disabled with mode blob\n",
502 * drm_atomic_get_plane_state - get plane state
503 * @state: global atomic state object
504 * @plane: plane to get state object for
506 * This function returns the plane state for the given plane, allocating it if
507 * needed. It will also grab the relevant plane lock to make sure that the state
512 * Either the allocated state or the error code encoded into the pointer. When
513 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
514 * entire atomic sequence must be restarted. All other errors are fatal.
516 struct drm_plane_state
*
517 drm_atomic_get_plane_state(struct drm_atomic_state
*state
,
518 struct drm_plane
*plane
)
520 int ret
, index
= drm_plane_index(plane
);
521 struct drm_plane_state
*plane_state
;
523 plane_state
= drm_atomic_get_existing_plane_state(state
, plane
);
527 ret
= drm_modeset_lock(&plane
->mutex
, state
->acquire_ctx
);
531 plane_state
= plane
->funcs
->atomic_duplicate_state(plane
);
533 return ERR_PTR(-ENOMEM
);
535 state
->plane_states
[index
] = plane_state
;
536 state
->planes
[index
] = plane
;
537 plane_state
->state
= state
;
539 DRM_DEBUG_ATOMIC("Added [PLANE:%d] %p state to %p\n",
540 plane
->base
.id
, plane_state
, state
);
542 if (plane_state
->crtc
) {
543 struct drm_crtc_state
*crtc_state
;
545 crtc_state
= drm_atomic_get_crtc_state(state
,
547 if (IS_ERR(crtc_state
))
548 return ERR_CAST(crtc_state
);
553 EXPORT_SYMBOL(drm_atomic_get_plane_state
);
556 * drm_atomic_plane_set_property - set property on plane
557 * @plane: the drm plane to set a property on
558 * @state: the state object to update with the new property value
559 * @property: the property to set
560 * @val: the new property value
562 * Use this instead of calling plane->atomic_set_property directly.
563 * This function handles generic/core properties and calls out to
564 * driver's ->atomic_set_property() for driver properties. To ensure
565 * consistent behavior you must call this function rather than the
566 * driver hook directly.
569 * Zero on success, error code on failure
571 int drm_atomic_plane_set_property(struct drm_plane
*plane
,
572 struct drm_plane_state
*state
, struct drm_property
*property
,
575 struct drm_device
*dev
= plane
->dev
;
576 struct drm_mode_config
*config
= &dev
->mode_config
;
578 if (property
== config
->prop_fb_id
) {
579 struct drm_framebuffer
*fb
= drm_framebuffer_lookup(dev
, val
);
580 drm_atomic_set_fb_for_plane(state
, fb
);
582 drm_framebuffer_unreference(fb
);
583 } else if (property
== config
->prop_crtc_id
) {
584 struct drm_crtc
*crtc
= drm_crtc_find(dev
, val
);
585 return drm_atomic_set_crtc_for_plane(state
, crtc
);
586 } else if (property
== config
->prop_crtc_x
) {
587 state
->crtc_x
= U642I64(val
);
588 } else if (property
== config
->prop_crtc_y
) {
589 state
->crtc_y
= U642I64(val
);
590 } else if (property
== config
->prop_crtc_w
) {
592 } else if (property
== config
->prop_crtc_h
) {
594 } else if (property
== config
->prop_src_x
) {
596 } else if (property
== config
->prop_src_y
) {
598 } else if (property
== config
->prop_src_w
) {
600 } else if (property
== config
->prop_src_h
) {
602 } else if (property
== config
->rotation_property
) {
603 state
->rotation
= val
;
604 } else if (plane
->funcs
->atomic_set_property
) {
605 return plane
->funcs
->atomic_set_property(plane
, state
,
613 EXPORT_SYMBOL(drm_atomic_plane_set_property
);
616 * This function handles generic/core properties and calls out to
617 * driver's ->atomic_get_property() for driver properties. To ensure
618 * consistent behavior you must call this function rather than the
619 * driver hook directly.
622 drm_atomic_plane_get_property(struct drm_plane
*plane
,
623 const struct drm_plane_state
*state
,
624 struct drm_property
*property
, uint64_t *val
)
626 struct drm_device
*dev
= plane
->dev
;
627 struct drm_mode_config
*config
= &dev
->mode_config
;
629 if (property
== config
->prop_fb_id
) {
630 *val
= (state
->fb
) ? state
->fb
->base
.id
: 0;
631 } else if (property
== config
->prop_crtc_id
) {
632 *val
= (state
->crtc
) ? state
->crtc
->base
.id
: 0;
633 } else if (property
== config
->prop_crtc_x
) {
634 *val
= I642U64(state
->crtc_x
);
635 } else if (property
== config
->prop_crtc_y
) {
636 *val
= I642U64(state
->crtc_y
);
637 } else if (property
== config
->prop_crtc_w
) {
638 *val
= state
->crtc_w
;
639 } else if (property
== config
->prop_crtc_h
) {
640 *val
= state
->crtc_h
;
641 } else if (property
== config
->prop_src_x
) {
643 } else if (property
== config
->prop_src_y
) {
645 } else if (property
== config
->prop_src_w
) {
647 } else if (property
== config
->prop_src_h
) {
649 } else if (property
== config
->rotation_property
) {
650 *val
= state
->rotation
;
651 } else if (plane
->funcs
->atomic_get_property
) {
652 return plane
->funcs
->atomic_get_property(plane
, state
, property
, val
);
661 * drm_atomic_plane_check - check plane state
662 * @plane: plane to check
663 * @state: plane state to check
665 * Provides core sanity checks for plane state.
668 * Zero on success, error code on failure
670 static int drm_atomic_plane_check(struct drm_plane
*plane
,
671 struct drm_plane_state
*state
)
673 unsigned int fb_width
, fb_height
;
676 /* either *both* CRTC and FB must be set, or neither */
677 if (WARN_ON(state
->crtc
&& !state
->fb
)) {
678 DRM_DEBUG_ATOMIC("CRTC set but no FB\n");
680 } else if (WARN_ON(state
->fb
&& !state
->crtc
)) {
681 DRM_DEBUG_ATOMIC("FB set but no CRTC\n");
685 /* if disabled, we don't care about the rest of the state: */
689 /* Check whether this plane is usable on this CRTC */
690 if (!(plane
->possible_crtcs
& drm_crtc_mask(state
->crtc
))) {
691 DRM_DEBUG_ATOMIC("Invalid crtc for plane\n");
695 /* Check whether this plane supports the fb pixel format. */
696 ret
= drm_plane_check_pixel_format(plane
, state
->fb
->pixel_format
);
698 DRM_DEBUG_ATOMIC("Invalid pixel format %s\n",
699 drm_get_format_name(state
->fb
->pixel_format
));
703 /* Give drivers some help against integer overflows */
704 if (state
->crtc_w
> INT_MAX
||
705 state
->crtc_x
> INT_MAX
- (int32_t) state
->crtc_w
||
706 state
->crtc_h
> INT_MAX
||
707 state
->crtc_y
> INT_MAX
- (int32_t) state
->crtc_h
) {
708 DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n",
709 state
->crtc_w
, state
->crtc_h
,
710 state
->crtc_x
, state
->crtc_y
);
714 fb_width
= state
->fb
->width
<< 16;
715 fb_height
= state
->fb
->height
<< 16;
717 /* Make sure source coordinates are inside the fb. */
718 if (state
->src_w
> fb_width
||
719 state
->src_x
> fb_width
- state
->src_w
||
720 state
->src_h
> fb_height
||
721 state
->src_y
> fb_height
- state
->src_h
) {
722 DRM_DEBUG_ATOMIC("Invalid source coordinates "
723 "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
724 state
->src_w
>> 16, ((state
->src_w
& 0xffff) * 15625) >> 10,
725 state
->src_h
>> 16, ((state
->src_h
& 0xffff) * 15625) >> 10,
726 state
->src_x
>> 16, ((state
->src_x
& 0xffff) * 15625) >> 10,
727 state
->src_y
>> 16, ((state
->src_y
& 0xffff) * 15625) >> 10);
735 * drm_atomic_get_connector_state - get connector state
736 * @state: global atomic state object
737 * @connector: connector to get state object for
739 * This function returns the connector state for the given connector,
740 * allocating it if needed. It will also grab the relevant connector lock to
741 * make sure that the state is consistent.
745 * Either the allocated state or the error code encoded into the pointer. When
746 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
747 * entire atomic sequence must be restarted. All other errors are fatal.
749 struct drm_connector_state
*
750 drm_atomic_get_connector_state(struct drm_atomic_state
*state
,
751 struct drm_connector
*connector
)
754 struct drm_mode_config
*config
= &connector
->dev
->mode_config
;
755 struct drm_connector_state
*connector_state
;
757 ret
= drm_modeset_lock(&config
->connection_mutex
, state
->acquire_ctx
);
761 index
= drm_connector_index(connector
);
764 * Construction of atomic state updates can race with a connector
765 * hot-add which might overflow. In this case flip the table and just
766 * restart the entire ioctl - no one is fast enough to livelock a cpu
767 * with physical hotplug events anyway.
769 * Note that we only grab the indexes once we have the right lock to
770 * prevent hotplug/unplugging of connectors. So removal is no problem,
771 * at most the array is a bit too large.
773 if (index
>= state
->num_connector
) {
774 DRM_DEBUG_ATOMIC("Hot-added connector would overflow state array, restarting\n");
775 return ERR_PTR(-EAGAIN
);
778 if (state
->connector_states
[index
])
779 return state
->connector_states
[index
];
781 connector_state
= connector
->funcs
->atomic_duplicate_state(connector
);
782 if (!connector_state
)
783 return ERR_PTR(-ENOMEM
);
785 state
->connector_states
[index
] = connector_state
;
786 state
->connectors
[index
] = connector
;
787 connector_state
->state
= state
;
789 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d] %p state to %p\n",
790 connector
->base
.id
, connector_state
, state
);
792 if (connector_state
->crtc
) {
793 struct drm_crtc_state
*crtc_state
;
795 crtc_state
= drm_atomic_get_crtc_state(state
,
796 connector_state
->crtc
);
797 if (IS_ERR(crtc_state
))
798 return ERR_CAST(crtc_state
);
801 return connector_state
;
803 EXPORT_SYMBOL(drm_atomic_get_connector_state
);
806 * drm_atomic_connector_set_property - set property on connector.
807 * @connector: the drm connector to set a property on
808 * @state: the state object to update with the new property value
809 * @property: the property to set
810 * @val: the new property value
812 * Use this instead of calling connector->atomic_set_property directly.
813 * This function handles generic/core properties and calls out to
814 * driver's ->atomic_set_property() for driver properties. To ensure
815 * consistent behavior you must call this function rather than the
816 * driver hook directly.
819 * Zero on success, error code on failure
821 int drm_atomic_connector_set_property(struct drm_connector
*connector
,
822 struct drm_connector_state
*state
, struct drm_property
*property
,
825 struct drm_device
*dev
= connector
->dev
;
826 struct drm_mode_config
*config
= &dev
->mode_config
;
828 if (property
== config
->prop_crtc_id
) {
829 struct drm_crtc
*crtc
= drm_crtc_find(dev
, val
);
830 return drm_atomic_set_crtc_for_connector(state
, crtc
);
831 } else if (property
== config
->dpms_property
) {
832 /* setting DPMS property requires special handling, which
833 * is done in legacy setprop path for us. Disallow (for
834 * now?) atomic writes to DPMS property:
837 } else if (connector
->funcs
->atomic_set_property
) {
838 return connector
->funcs
->atomic_set_property(connector
,
839 state
, property
, val
);
844 EXPORT_SYMBOL(drm_atomic_connector_set_property
);
847 * This function handles generic/core properties and calls out to
848 * driver's ->atomic_get_property() for driver properties. To ensure
849 * consistent behavior you must call this function rather than the
850 * driver hook directly.
853 drm_atomic_connector_get_property(struct drm_connector
*connector
,
854 const struct drm_connector_state
*state
,
855 struct drm_property
*property
, uint64_t *val
)
857 struct drm_device
*dev
= connector
->dev
;
858 struct drm_mode_config
*config
= &dev
->mode_config
;
860 if (property
== config
->prop_crtc_id
) {
861 *val
= (state
->crtc
) ? state
->crtc
->base
.id
: 0;
862 } else if (property
== config
->dpms_property
) {
863 *val
= connector
->dpms
;
864 } else if (connector
->funcs
->atomic_get_property
) {
865 return connector
->funcs
->atomic_get_property(connector
,
866 state
, property
, val
);
874 int drm_atomic_get_property(struct drm_mode_object
*obj
,
875 struct drm_property
*property
, uint64_t *val
)
877 struct drm_device
*dev
= property
->dev
;
881 case DRM_MODE_OBJECT_CONNECTOR
: {
882 struct drm_connector
*connector
= obj_to_connector(obj
);
883 WARN_ON(!drm_modeset_is_locked(&dev
->mode_config
.connection_mutex
));
884 ret
= drm_atomic_connector_get_property(connector
,
885 connector
->state
, property
, val
);
888 case DRM_MODE_OBJECT_CRTC
: {
889 struct drm_crtc
*crtc
= obj_to_crtc(obj
);
890 WARN_ON(!drm_modeset_is_locked(&crtc
->mutex
));
891 ret
= drm_atomic_crtc_get_property(crtc
,
892 crtc
->state
, property
, val
);
895 case DRM_MODE_OBJECT_PLANE
: {
896 struct drm_plane
*plane
= obj_to_plane(obj
);
897 WARN_ON(!drm_modeset_is_locked(&plane
->mutex
));
898 ret
= drm_atomic_plane_get_property(plane
,
899 plane
->state
, property
, val
);
911 * drm_atomic_set_crtc_for_plane - set crtc for plane
912 * @plane_state: the plane whose incoming state to update
913 * @crtc: crtc to use for the plane
915 * Changing the assigned crtc for a plane requires us to grab the lock and state
916 * for the new crtc, as needed. This function takes care of all these details
917 * besides updating the pointer in the state object itself.
920 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
921 * then the w/w mutex code has detected a deadlock and the entire atomic
922 * sequence must be restarted. All other errors are fatal.
925 drm_atomic_set_crtc_for_plane(struct drm_plane_state
*plane_state
,
926 struct drm_crtc
*crtc
)
928 struct drm_plane
*plane
= plane_state
->plane
;
929 struct drm_crtc_state
*crtc_state
;
931 if (plane_state
->crtc
) {
932 crtc_state
= drm_atomic_get_crtc_state(plane_state
->state
,
934 if (WARN_ON(IS_ERR(crtc_state
)))
935 return PTR_ERR(crtc_state
);
937 crtc_state
->plane_mask
&= ~(1 << drm_plane_index(plane
));
940 plane_state
->crtc
= crtc
;
943 crtc_state
= drm_atomic_get_crtc_state(plane_state
->state
,
945 if (IS_ERR(crtc_state
))
946 return PTR_ERR(crtc_state
);
947 crtc_state
->plane_mask
|= (1 << drm_plane_index(plane
));
951 DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d]\n",
952 plane_state
, crtc
->base
.id
);
954 DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n",
959 EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane
);
962 * drm_atomic_set_fb_for_plane - set framebuffer for plane
963 * @plane_state: atomic state object for the plane
964 * @fb: fb to use for the plane
966 * Changing the assigned framebuffer for a plane requires us to grab a reference
967 * to the new fb and drop the reference to the old fb, if there is one. This
968 * function takes care of all these details besides updating the pointer in the
969 * state object itself.
972 drm_atomic_set_fb_for_plane(struct drm_plane_state
*plane_state
,
973 struct drm_framebuffer
*fb
)
976 drm_framebuffer_unreference(plane_state
->fb
);
978 drm_framebuffer_reference(fb
);
979 plane_state
->fb
= fb
;
982 DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n",
983 fb
->base
.id
, plane_state
);
985 DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n",
988 EXPORT_SYMBOL(drm_atomic_set_fb_for_plane
);
991 * drm_atomic_set_crtc_for_connector - set crtc for connector
992 * @conn_state: atomic state object for the connector
993 * @crtc: crtc to use for the connector
995 * Changing the assigned crtc for a connector requires us to grab the lock and
996 * state for the new crtc, as needed. This function takes care of all these
997 * details besides updating the pointer in the state object itself.
1000 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1001 * then the w/w mutex code has detected a deadlock and the entire atomic
1002 * sequence must be restarted. All other errors are fatal.
1005 drm_atomic_set_crtc_for_connector(struct drm_connector_state
*conn_state
,
1006 struct drm_crtc
*crtc
)
1008 struct drm_crtc_state
*crtc_state
;
1011 crtc_state
= drm_atomic_get_crtc_state(conn_state
->state
, crtc
);
1012 if (IS_ERR(crtc_state
))
1013 return PTR_ERR(crtc_state
);
1016 conn_state
->crtc
= crtc
;
1019 DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d]\n",
1020 conn_state
, crtc
->base
.id
);
1022 DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n",
1027 EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector
);
1030 * drm_atomic_add_affected_connectors - add connectors for crtc
1031 * @state: atomic state
1034 * This function walks the current configuration and adds all connectors
1035 * currently using @crtc to the atomic configuration @state. Note that this
1036 * function must acquire the connection mutex. This can potentially cause
1037 * unneeded seralization if the update is just for the planes on one crtc. Hence
1038 * drivers and helpers should only call this when really needed (e.g. when a
1039 * full modeset needs to happen due to some change).
1042 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1043 * then the w/w mutex code has detected a deadlock and the entire atomic
1044 * sequence must be restarted. All other errors are fatal.
1047 drm_atomic_add_affected_connectors(struct drm_atomic_state
*state
,
1048 struct drm_crtc
*crtc
)
1050 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1051 struct drm_connector
*connector
;
1052 struct drm_connector_state
*conn_state
;
1055 ret
= drm_modeset_lock(&config
->connection_mutex
, state
->acquire_ctx
);
1059 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d] to %p\n",
1060 crtc
->base
.id
, state
);
1063 * Changed connectors are already in @state, so only need to look at the
1064 * current configuration.
1066 list_for_each_entry(connector
, &config
->connector_list
, head
) {
1067 if (connector
->state
->crtc
!= crtc
)
1070 conn_state
= drm_atomic_get_connector_state(state
, connector
);
1071 if (IS_ERR(conn_state
))
1072 return PTR_ERR(conn_state
);
1077 EXPORT_SYMBOL(drm_atomic_add_affected_connectors
);
1080 * drm_atomic_add_affected_planes - add planes for crtc
1081 * @state: atomic state
1084 * This function walks the current configuration and adds all planes
1085 * currently used by @crtc to the atomic configuration @state. This is useful
1086 * when an atomic commit also needs to check all currently enabled plane on
1087 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1088 * to avoid special code to force-enable all planes.
1090 * Since acquiring a plane state will always also acquire the w/w mutex of the
1091 * current CRTC for that plane (if there is any) adding all the plane states for
1092 * a CRTC will not reduce parallism of atomic updates.
1095 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1096 * then the w/w mutex code has detected a deadlock and the entire atomic
1097 * sequence must be restarted. All other errors are fatal.
1100 drm_atomic_add_affected_planes(struct drm_atomic_state
*state
,
1101 struct drm_crtc
*crtc
)
1103 struct drm_plane
*plane
;
1105 WARN_ON(!drm_atomic_get_existing_crtc_state(state
, crtc
));
1107 drm_for_each_plane_mask(plane
, state
->dev
, crtc
->state
->plane_mask
) {
1108 struct drm_plane_state
*plane_state
=
1109 drm_atomic_get_plane_state(state
, plane
);
1111 if (IS_ERR(plane_state
))
1112 return PTR_ERR(plane_state
);
1116 EXPORT_SYMBOL(drm_atomic_add_affected_planes
);
1119 * drm_atomic_connectors_for_crtc - count number of connected outputs
1120 * @state: atomic state
1123 * This function counts all connectors which will be connected to @crtc
1124 * according to @state. Useful to recompute the enable state for @crtc.
1127 drm_atomic_connectors_for_crtc(struct drm_atomic_state
*state
,
1128 struct drm_crtc
*crtc
)
1130 struct drm_connector
*connector
;
1131 struct drm_connector_state
*conn_state
;
1133 int i
, num_connected_connectors
= 0;
1135 for_each_connector_in_state(state
, connector
, conn_state
, i
) {
1136 if (conn_state
->crtc
== crtc
)
1137 num_connected_connectors
++;
1140 DRM_DEBUG_ATOMIC("State %p has %i connectors for [CRTC:%d]\n",
1141 state
, num_connected_connectors
, crtc
->base
.id
);
1143 return num_connected_connectors
;
1145 EXPORT_SYMBOL(drm_atomic_connectors_for_crtc
);
1148 * drm_atomic_legacy_backoff - locking backoff for legacy ioctls
1149 * @state: atomic state
1151 * This function should be used by legacy entry points which don't understand
1152 * -EDEADLK semantics. For simplicity this one will grab all modeset locks after
1153 * the slowpath completed.
1155 void drm_atomic_legacy_backoff(struct drm_atomic_state
*state
)
1160 drm_modeset_backoff(state
->acquire_ctx
);
1162 ret
= drm_modeset_lock(&state
->dev
->mode_config
.connection_mutex
,
1163 state
->acquire_ctx
);
1166 ret
= drm_modeset_lock_all_crtcs(state
->dev
,
1167 state
->acquire_ctx
);
1171 EXPORT_SYMBOL(drm_atomic_legacy_backoff
);
1174 * drm_atomic_check_only - check whether a given config would work
1175 * @state: atomic configuration to check
1177 * Note that this function can return -EDEADLK if the driver needed to acquire
1178 * more locks but encountered a deadlock. The caller must then do the usual w/w
1179 * backoff dance and restart. All other errors are fatal.
1182 * 0 on success, negative error code on failure.
1184 int drm_atomic_check_only(struct drm_atomic_state
*state
)
1186 struct drm_device
*dev
= state
->dev
;
1187 struct drm_mode_config
*config
= &dev
->mode_config
;
1188 struct drm_plane
*plane
;
1189 struct drm_plane_state
*plane_state
;
1190 struct drm_crtc
*crtc
;
1191 struct drm_crtc_state
*crtc_state
;
1194 DRM_DEBUG_ATOMIC("checking %p\n", state
);
1196 for_each_plane_in_state(state
, plane
, plane_state
, i
) {
1197 ret
= drm_atomic_plane_check(plane
, plane_state
);
1199 DRM_DEBUG_ATOMIC("[PLANE:%d] atomic core check failed\n",
1205 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1206 ret
= drm_atomic_crtc_check(crtc
, crtc_state
);
1208 DRM_DEBUG_ATOMIC("[CRTC:%d] atomic core check failed\n",
1214 if (config
->funcs
->atomic_check
)
1215 ret
= config
->funcs
->atomic_check(state
->dev
, state
);
1217 if (!state
->allow_modeset
) {
1218 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1219 if (drm_atomic_crtc_needs_modeset(crtc_state
)) {
1220 DRM_DEBUG_ATOMIC("[CRTC:%d] requires full modeset\n",
1229 EXPORT_SYMBOL(drm_atomic_check_only
);
1232 * drm_atomic_commit - commit configuration atomically
1233 * @state: atomic configuration to check
1235 * Note that this function can return -EDEADLK if the driver needed to acquire
1236 * more locks but encountered a deadlock. The caller must then do the usual w/w
1237 * backoff dance and restart. All other errors are fatal.
1239 * Also note that on successful execution ownership of @state is transferred
1240 * from the caller of this function to the function itself. The caller must not
1241 * free or in any other way access @state. If the function fails then the caller
1242 * must clean up @state itself.
1245 * 0 on success, negative error code on failure.
1247 int drm_atomic_commit(struct drm_atomic_state
*state
)
1249 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1252 ret
= drm_atomic_check_only(state
);
1256 DRM_DEBUG_ATOMIC("commiting %p\n", state
);
1258 return config
->funcs
->atomic_commit(state
->dev
, state
, false);
1260 EXPORT_SYMBOL(drm_atomic_commit
);
1263 * drm_atomic_async_commit - atomic&async configuration commit
1264 * @state: atomic configuration to check
1266 * Note that this function can return -EDEADLK if the driver needed to acquire
1267 * more locks but encountered a deadlock. The caller must then do the usual w/w
1268 * backoff dance and restart. All other errors are fatal.
1270 * Also note that on successful execution ownership of @state is transferred
1271 * from the caller of this function to the function itself. The caller must not
1272 * free or in any other way access @state. If the function fails then the caller
1273 * must clean up @state itself.
1276 * 0 on success, negative error code on failure.
1278 int drm_atomic_async_commit(struct drm_atomic_state
*state
)
1280 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1283 ret
= drm_atomic_check_only(state
);
1287 DRM_DEBUG_ATOMIC("commiting %p asynchronously\n", state
);
1289 return config
->funcs
->atomic_commit(state
->dev
, state
, true);
1291 EXPORT_SYMBOL(drm_atomic_async_commit
);
1294 * The big monstor ioctl
1297 static struct drm_pending_vblank_event
*create_vblank_event(
1298 struct drm_device
*dev
, struct drm_file
*file_priv
, uint64_t user_data
)
1300 struct drm_pending_vblank_event
*e
= NULL
;
1301 unsigned long flags
;
1303 spin_lock_irqsave(&dev
->event_lock
, flags
);
1304 if (file_priv
->event_space
< sizeof e
->event
) {
1305 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
1308 file_priv
->event_space
-= sizeof e
->event
;
1309 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
1311 e
= kzalloc(sizeof *e
, GFP_KERNEL
);
1313 spin_lock_irqsave(&dev
->event_lock
, flags
);
1314 file_priv
->event_space
+= sizeof e
->event
;
1315 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
1319 e
->event
.base
.type
= DRM_EVENT_FLIP_COMPLETE
;
1320 e
->event
.base
.length
= sizeof e
->event
;
1321 e
->event
.user_data
= user_data
;
1322 e
->base
.event
= &e
->event
.base
;
1323 e
->base
.file_priv
= file_priv
;
1324 e
->base
.destroy
= (void (*) (struct drm_pending_event
*)) kfree
;
1330 static void destroy_vblank_event(struct drm_device
*dev
,
1331 struct drm_file
*file_priv
, struct drm_pending_vblank_event
*e
)
1333 unsigned long flags
;
1335 spin_lock_irqsave(&dev
->event_lock
, flags
);
1336 file_priv
->event_space
+= sizeof e
->event
;
1337 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
1341 static int atomic_set_prop(struct drm_atomic_state
*state
,
1342 struct drm_mode_object
*obj
, struct drm_property
*prop
,
1343 uint64_t prop_value
)
1345 struct drm_mode_object
*ref
;
1348 if (!drm_property_change_valid_get(prop
, prop_value
, &ref
))
1351 switch (obj
->type
) {
1352 case DRM_MODE_OBJECT_CONNECTOR
: {
1353 struct drm_connector
*connector
= obj_to_connector(obj
);
1354 struct drm_connector_state
*connector_state
;
1356 connector_state
= drm_atomic_get_connector_state(state
, connector
);
1357 if (IS_ERR(connector_state
)) {
1358 ret
= PTR_ERR(connector_state
);
1362 ret
= drm_atomic_connector_set_property(connector
,
1363 connector_state
, prop
, prop_value
);
1366 case DRM_MODE_OBJECT_CRTC
: {
1367 struct drm_crtc
*crtc
= obj_to_crtc(obj
);
1368 struct drm_crtc_state
*crtc_state
;
1370 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
1371 if (IS_ERR(crtc_state
)) {
1372 ret
= PTR_ERR(crtc_state
);
1376 ret
= drm_atomic_crtc_set_property(crtc
,
1377 crtc_state
, prop
, prop_value
);
1380 case DRM_MODE_OBJECT_PLANE
: {
1381 struct drm_plane
*plane
= obj_to_plane(obj
);
1382 struct drm_plane_state
*plane_state
;
1384 plane_state
= drm_atomic_get_plane_state(state
, plane
);
1385 if (IS_ERR(plane_state
)) {
1386 ret
= PTR_ERR(plane_state
);
1390 ret
= drm_atomic_plane_set_property(plane
,
1391 plane_state
, prop
, prop_value
);
1399 drm_property_change_valid_put(prop
, ref
);
1403 int drm_mode_atomic_ioctl(struct drm_device
*dev
,
1404 void *data
, struct drm_file
*file_priv
)
1406 struct drm_mode_atomic
*arg
= data
;
1407 uint32_t __user
*objs_ptr
= (uint32_t __user
*)(unsigned long)(arg
->objs_ptr
);
1408 uint32_t __user
*count_props_ptr
= (uint32_t __user
*)(unsigned long)(arg
->count_props_ptr
);
1409 uint32_t __user
*props_ptr
= (uint32_t __user
*)(unsigned long)(arg
->props_ptr
);
1410 uint64_t __user
*prop_values_ptr
= (uint64_t __user
*)(unsigned long)(arg
->prop_values_ptr
);
1411 unsigned int copied_objs
, copied_props
;
1412 struct drm_atomic_state
*state
;
1413 struct drm_modeset_acquire_ctx ctx
;
1414 struct drm_plane
*plane
;
1415 struct drm_crtc
*crtc
;
1416 struct drm_crtc_state
*crtc_state
;
1417 unsigned plane_mask
= 0;
1421 /* disallow for drivers not supporting atomic: */
1422 if (!drm_core_check_feature(dev
, DRIVER_ATOMIC
))
1425 /* disallow for userspace that has not enabled atomic cap (even
1426 * though this may be a bit overkill, since legacy userspace
1427 * wouldn't know how to call this ioctl)
1429 if (!file_priv
->atomic
)
1432 if (arg
->flags
& ~DRM_MODE_ATOMIC_FLAGS
)
1438 if ((arg
->flags
& DRM_MODE_PAGE_FLIP_ASYNC
) &&
1439 !dev
->mode_config
.async_page_flip
)
1442 /* can't test and expect an event at the same time. */
1443 if ((arg
->flags
& DRM_MODE_ATOMIC_TEST_ONLY
) &&
1444 (arg
->flags
& DRM_MODE_PAGE_FLIP_EVENT
))
1447 drm_modeset_acquire_init(&ctx
, 0);
1449 state
= drm_atomic_state_alloc(dev
);
1453 state
->acquire_ctx
= &ctx
;
1454 state
->allow_modeset
= !!(arg
->flags
& DRM_MODE_ATOMIC_ALLOW_MODESET
);
1460 for (i
= 0; i
< arg
->count_objs
; i
++) {
1461 uint32_t obj_id
, count_props
;
1462 struct drm_mode_object
*obj
;
1464 if (get_user(obj_id
, objs_ptr
+ copied_objs
)) {
1469 obj
= drm_mode_object_find(dev
, obj_id
, DRM_MODE_OBJECT_ANY
);
1470 if (!obj
|| !obj
->properties
) {
1475 if (obj
->type
== DRM_MODE_OBJECT_PLANE
) {
1476 plane
= obj_to_plane(obj
);
1477 plane_mask
|= (1 << drm_plane_index(plane
));
1478 plane
->old_fb
= plane
->fb
;
1481 if (get_user(count_props
, count_props_ptr
+ copied_objs
)) {
1488 for (j
= 0; j
< count_props
; j
++) {
1490 uint64_t prop_value
;
1491 struct drm_property
*prop
;
1493 if (get_user(prop_id
, props_ptr
+ copied_props
)) {
1498 prop
= drm_property_find(dev
, prop_id
);
1504 if (copy_from_user(&prop_value
,
1505 prop_values_ptr
+ copied_props
,
1506 sizeof(prop_value
))) {
1511 ret
= atomic_set_prop(state
, obj
, prop
, prop_value
);
1519 if (arg
->flags
& DRM_MODE_PAGE_FLIP_EVENT
) {
1520 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1521 struct drm_pending_vblank_event
*e
;
1523 e
= create_vblank_event(dev
, file_priv
, arg
->user_data
);
1529 crtc_state
->event
= e
;
1533 if (arg
->flags
& DRM_MODE_ATOMIC_TEST_ONLY
) {
1534 ret
= drm_atomic_check_only(state
);
1535 /* _check_only() does not free state, unlike _commit() */
1536 drm_atomic_state_free(state
);
1537 } else if (arg
->flags
& DRM_MODE_ATOMIC_NONBLOCK
) {
1538 ret
= drm_atomic_async_commit(state
);
1540 ret
= drm_atomic_commit(state
);
1543 /* if succeeded, fixup legacy plane crtc/fb ptrs before dropping
1544 * locks (ie. while it is still safe to deref plane->state). We
1545 * need to do this here because the driver entry points cannot
1546 * distinguish between legacy and atomic ioctls.
1548 drm_for_each_plane_mask(plane
, dev
, plane_mask
) {
1550 struct drm_framebuffer
*new_fb
= plane
->state
->fb
;
1552 drm_framebuffer_reference(new_fb
);
1554 plane
->crtc
= plane
->state
->crtc
;
1556 plane
->old_fb
= NULL
;
1558 if (plane
->old_fb
) {
1559 drm_framebuffer_unreference(plane
->old_fb
);
1560 plane
->old_fb
= NULL
;
1564 drm_modeset_drop_locks(&ctx
);
1565 drm_modeset_acquire_fini(&ctx
);
1570 if (ret
== -EDEADLK
)
1573 if (arg
->flags
& DRM_MODE_PAGE_FLIP_EVENT
) {
1574 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1575 destroy_vblank_event(dev
, file_priv
, crtc_state
->event
);
1576 crtc_state
->event
= NULL
;
1580 drm_atomic_state_free(state
);
1582 drm_modeset_drop_locks(&ctx
);
1583 drm_modeset_acquire_fini(&ctx
);
1588 drm_atomic_state_clear(state
);
1589 drm_modeset_backoff(&ctx
);