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>
33 #include "drm_crtc_internal.h"
36 * drm_atomic_state_default_release -
37 * release memory initialized by drm_atomic_state_init
38 * @state: atomic state
40 * Free all the memory allocated by drm_atomic_state_init.
41 * This is useful for drivers that subclass the atomic state.
43 void drm_atomic_state_default_release(struct drm_atomic_state
*state
)
45 kfree(state
->connectors
);
46 kfree(state
->connector_states
);
48 kfree(state
->crtc_states
);
50 kfree(state
->plane_states
);
52 EXPORT_SYMBOL(drm_atomic_state_default_release
);
55 * drm_atomic_state_init - init new atomic state
57 * @state: atomic state
59 * Default implementation for filling in a new atomic state.
60 * This is useful for drivers that subclass the atomic state.
63 drm_atomic_state_init(struct drm_device
*dev
, struct drm_atomic_state
*state
)
65 /* TODO legacy paths should maybe do a better job about
66 * setting this appropriately?
68 state
->allow_modeset
= true;
70 state
->num_connector
= ACCESS_ONCE(dev
->mode_config
.num_connector
);
72 state
->crtcs
= kcalloc(dev
->mode_config
.num_crtc
,
73 sizeof(*state
->crtcs
), GFP_KERNEL
);
76 state
->crtc_states
= kcalloc(dev
->mode_config
.num_crtc
,
77 sizeof(*state
->crtc_states
), GFP_KERNEL
);
78 if (!state
->crtc_states
)
80 state
->planes
= kcalloc(dev
->mode_config
.num_total_plane
,
81 sizeof(*state
->planes
), GFP_KERNEL
);
84 state
->plane_states
= kcalloc(dev
->mode_config
.num_total_plane
,
85 sizeof(*state
->plane_states
), GFP_KERNEL
);
86 if (!state
->plane_states
)
88 state
->connectors
= kcalloc(state
->num_connector
,
89 sizeof(*state
->connectors
),
91 if (!state
->connectors
)
93 state
->connector_states
= kcalloc(state
->num_connector
,
94 sizeof(*state
->connector_states
),
96 if (!state
->connector_states
)
101 DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state
);
105 drm_atomic_state_default_release(state
);
108 EXPORT_SYMBOL(drm_atomic_state_init
);
111 * drm_atomic_state_alloc - allocate atomic state
114 * This allocates an empty atomic state to track updates.
116 struct drm_atomic_state
*
117 drm_atomic_state_alloc(struct drm_device
*dev
)
119 struct drm_mode_config
*config
= &dev
->mode_config
;
120 struct drm_atomic_state
*state
;
122 if (!config
->funcs
->atomic_state_alloc
) {
123 state
= kzalloc(sizeof(*state
), GFP_KERNEL
);
126 if (drm_atomic_state_init(dev
, state
) < 0) {
133 return config
->funcs
->atomic_state_alloc(dev
);
135 EXPORT_SYMBOL(drm_atomic_state_alloc
);
138 * drm_atomic_state_default_clear - clear base atomic state
139 * @state: atomic state
141 * Default implementation for clearing atomic state.
142 * This is useful for drivers that subclass the atomic state.
144 void drm_atomic_state_default_clear(struct drm_atomic_state
*state
)
146 struct drm_device
*dev
= state
->dev
;
147 struct drm_mode_config
*config
= &dev
->mode_config
;
150 DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state
);
152 for (i
= 0; i
< state
->num_connector
; i
++) {
153 struct drm_connector
*connector
= state
->connectors
[i
];
159 * FIXME: Async commits can race with connector unplugging and
160 * there's currently nothing that prevents cleanup up state for
161 * deleted connectors. As long as the callback doesn't look at
162 * the connector we'll be fine though, so make sure that's the
163 * case by setting all connector pointers to NULL.
165 state
->connector_states
[i
]->connector
= NULL
;
166 connector
->funcs
->atomic_destroy_state(NULL
,
167 state
->connector_states
[i
]);
168 state
->connectors
[i
] = NULL
;
169 state
->connector_states
[i
] = NULL
;
172 for (i
= 0; i
< config
->num_crtc
; i
++) {
173 struct drm_crtc
*crtc
= state
->crtcs
[i
];
178 crtc
->funcs
->atomic_destroy_state(crtc
,
179 state
->crtc_states
[i
]);
180 state
->crtcs
[i
] = NULL
;
181 state
->crtc_states
[i
] = NULL
;
184 for (i
= 0; i
< config
->num_total_plane
; i
++) {
185 struct drm_plane
*plane
= state
->planes
[i
];
190 plane
->funcs
->atomic_destroy_state(plane
,
191 state
->plane_states
[i
]);
192 state
->planes
[i
] = NULL
;
193 state
->plane_states
[i
] = NULL
;
196 EXPORT_SYMBOL(drm_atomic_state_default_clear
);
199 * drm_atomic_state_clear - clear state object
200 * @state: atomic state
202 * When the w/w mutex algorithm detects a deadlock we need to back off and drop
203 * all locks. So someone else could sneak in and change the current modeset
204 * configuration. Which means that all the state assembled in @state is no
205 * longer an atomic update to the current state, but to some arbitrary earlier
206 * state. Which could break assumptions the driver's ->atomic_check likely
209 * Hence we must clear all cached state and completely start over, using this
212 void drm_atomic_state_clear(struct drm_atomic_state
*state
)
214 struct drm_device
*dev
= state
->dev
;
215 struct drm_mode_config
*config
= &dev
->mode_config
;
217 if (config
->funcs
->atomic_state_clear
)
218 config
->funcs
->atomic_state_clear(state
);
220 drm_atomic_state_default_clear(state
);
222 EXPORT_SYMBOL(drm_atomic_state_clear
);
225 * drm_atomic_state_free - free all memory for an atomic state
226 * @state: atomic state to deallocate
228 * This frees all memory associated with an atomic state, including all the
229 * per-object state for planes, crtcs and connectors.
231 void drm_atomic_state_free(struct drm_atomic_state
*state
)
233 struct drm_device
*dev
;
234 struct drm_mode_config
*config
;
240 config
= &dev
->mode_config
;
242 drm_atomic_state_clear(state
);
244 DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state
);
246 if (config
->funcs
->atomic_state_free
) {
247 config
->funcs
->atomic_state_free(state
);
249 drm_atomic_state_default_release(state
);
253 EXPORT_SYMBOL(drm_atomic_state_free
);
256 * drm_atomic_get_crtc_state - get crtc state
257 * @state: global atomic state object
258 * @crtc: crtc to get state object for
260 * This function returns the crtc state for the given crtc, allocating it if
261 * needed. It will also grab the relevant crtc lock to make sure that the state
266 * Either the allocated state or the error code encoded into the pointer. When
267 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
268 * entire atomic sequence must be restarted. All other errors are fatal.
270 struct drm_crtc_state
*
271 drm_atomic_get_crtc_state(struct drm_atomic_state
*state
,
272 struct drm_crtc
*crtc
)
274 int ret
, index
= drm_crtc_index(crtc
);
275 struct drm_crtc_state
*crtc_state
;
277 crtc_state
= drm_atomic_get_existing_crtc_state(state
, crtc
);
281 ret
= drm_modeset_lock(&crtc
->mutex
, state
->acquire_ctx
);
285 crtc_state
= crtc
->funcs
->atomic_duplicate_state(crtc
);
287 return ERR_PTR(-ENOMEM
);
289 state
->crtc_states
[index
] = crtc_state
;
290 state
->crtcs
[index
] = crtc
;
291 crtc_state
->state
= state
;
293 DRM_DEBUG_ATOMIC("Added [CRTC:%d] %p state to %p\n",
294 crtc
->base
.id
, crtc_state
, state
);
298 EXPORT_SYMBOL(drm_atomic_get_crtc_state
);
301 * drm_atomic_set_mode_for_crtc - set mode for CRTC
302 * @state: the CRTC whose incoming state to update
303 * @mode: kernel-internal mode to use for the CRTC, or NULL to disable
305 * Set a mode (originating from the kernel) on the desired CRTC state. Does
306 * not change any other state properties, including enable, active, or
310 * Zero on success, error code on failure. Cannot return -EDEADLK.
312 int drm_atomic_set_mode_for_crtc(struct drm_crtc_state
*state
,
313 struct drm_display_mode
*mode
)
315 struct drm_mode_modeinfo umode
;
317 /* Early return for no change. */
318 if (mode
&& memcmp(&state
->mode
, mode
, sizeof(*mode
)) == 0)
321 if (state
->mode_blob
)
322 drm_property_unreference_blob(state
->mode_blob
);
323 state
->mode_blob
= NULL
;
326 drm_mode_convert_to_umode(&umode
, mode
);
328 drm_property_create_blob(state
->crtc
->dev
,
331 if (IS_ERR(state
->mode_blob
))
332 return PTR_ERR(state
->mode_blob
);
334 drm_mode_copy(&state
->mode
, mode
);
335 state
->enable
= true;
336 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
339 memset(&state
->mode
, 0, sizeof(state
->mode
));
340 state
->enable
= false;
341 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
347 EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc
);
350 * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC
351 * @state: the CRTC whose incoming state to update
352 * @blob: pointer to blob property to use for mode
354 * Set a mode (originating from a blob property) on the desired CRTC state.
355 * This function will take a reference on the blob property for the CRTC state,
356 * and release the reference held on the state's existing mode property, if any
360 * Zero on success, error code on failure. Cannot return -EDEADLK.
362 int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state
*state
,
363 struct drm_property_blob
*blob
)
365 if (blob
== state
->mode_blob
)
368 if (state
->mode_blob
)
369 drm_property_unreference_blob(state
->mode_blob
);
370 state
->mode_blob
= NULL
;
373 if (blob
->length
!= sizeof(struct drm_mode_modeinfo
) ||
374 drm_mode_convert_umode(&state
->mode
,
375 (const struct drm_mode_modeinfo
*)
379 state
->mode_blob
= drm_property_reference_blob(blob
);
380 state
->enable
= true;
381 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
382 state
->mode
.name
, state
);
384 memset(&state
->mode
, 0, sizeof(state
->mode
));
385 state
->enable
= false;
386 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
392 EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc
);
395 * drm_atomic_crtc_set_property - set property on CRTC
396 * @crtc: the drm CRTC to set a property on
397 * @state: the state object to update with the new property value
398 * @property: the property to set
399 * @val: the new property value
401 * Use this instead of calling crtc->atomic_set_property directly.
402 * This function handles generic/core properties and calls out to
403 * driver's ->atomic_set_property() for driver properties. To ensure
404 * consistent behavior you must call this function rather than the
405 * driver hook directly.
408 * Zero on success, error code on failure
410 int drm_atomic_crtc_set_property(struct drm_crtc
*crtc
,
411 struct drm_crtc_state
*state
, struct drm_property
*property
,
414 struct drm_device
*dev
= crtc
->dev
;
415 struct drm_mode_config
*config
= &dev
->mode_config
;
418 if (property
== config
->prop_active
)
420 else if (property
== config
->prop_mode_id
) {
421 struct drm_property_blob
*mode
=
422 drm_property_lookup_blob(dev
, val
);
423 ret
= drm_atomic_set_mode_prop_for_crtc(state
, mode
);
425 drm_property_unreference_blob(mode
);
428 else if (crtc
->funcs
->atomic_set_property
)
429 return crtc
->funcs
->atomic_set_property(crtc
, state
, property
, val
);
435 EXPORT_SYMBOL(drm_atomic_crtc_set_property
);
438 * This function handles generic/core properties and calls out to
439 * driver's ->atomic_get_property() for driver properties. To ensure
440 * consistent behavior you must call this function rather than the
441 * driver hook directly.
444 drm_atomic_crtc_get_property(struct drm_crtc
*crtc
,
445 const struct drm_crtc_state
*state
,
446 struct drm_property
*property
, uint64_t *val
)
448 struct drm_device
*dev
= crtc
->dev
;
449 struct drm_mode_config
*config
= &dev
->mode_config
;
451 if (property
== config
->prop_active
)
452 *val
= state
->active
;
453 else if (property
== config
->prop_mode_id
)
454 *val
= (state
->mode_blob
) ? state
->mode_blob
->base
.id
: 0;
455 else if (crtc
->funcs
->atomic_get_property
)
456 return crtc
->funcs
->atomic_get_property(crtc
, state
, property
, val
);
464 * drm_atomic_crtc_check - check crtc state
465 * @crtc: crtc to check
466 * @state: crtc state to check
468 * Provides core sanity checks for crtc state.
471 * Zero on success, error code on failure
473 static int drm_atomic_crtc_check(struct drm_crtc
*crtc
,
474 struct drm_crtc_state
*state
)
476 /* NOTE: we explicitly don't enforce constraints such as primary
477 * layer covering entire screen, since that is something we want
478 * to allow (on hw that supports it). For hw that does not, it
479 * should be checked in driver's crtc->atomic_check() vfunc.
481 * TODO: Add generic modeset state checks once we support those.
484 if (state
->active
&& !state
->enable
) {
485 DRM_DEBUG_ATOMIC("[CRTC:%d] active without enabled\n",
490 /* The state->enable vs. state->mode_blob checks can be WARN_ON,
491 * as this is a kernel-internal detail that userspace should never
492 * be able to trigger. */
493 if (drm_core_check_feature(crtc
->dev
, DRIVER_ATOMIC
) &&
494 WARN_ON(state
->enable
&& !state
->mode_blob
)) {
495 DRM_DEBUG_ATOMIC("[CRTC:%d] enabled without mode blob\n",
500 if (drm_core_check_feature(crtc
->dev
, DRIVER_ATOMIC
) &&
501 WARN_ON(!state
->enable
&& state
->mode_blob
)) {
502 DRM_DEBUG_ATOMIC("[CRTC:%d] disabled with mode blob\n",
511 * drm_atomic_get_plane_state - get plane state
512 * @state: global atomic state object
513 * @plane: plane to get state object for
515 * This function returns the plane state for the given plane, allocating it if
516 * needed. It will also grab the relevant plane lock to make sure that the state
521 * Either the allocated state or the error code encoded into the pointer. When
522 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
523 * entire atomic sequence must be restarted. All other errors are fatal.
525 struct drm_plane_state
*
526 drm_atomic_get_plane_state(struct drm_atomic_state
*state
,
527 struct drm_plane
*plane
)
529 int ret
, index
= drm_plane_index(plane
);
530 struct drm_plane_state
*plane_state
;
532 plane_state
= drm_atomic_get_existing_plane_state(state
, plane
);
536 ret
= drm_modeset_lock(&plane
->mutex
, state
->acquire_ctx
);
540 plane_state
= plane
->funcs
->atomic_duplicate_state(plane
);
542 return ERR_PTR(-ENOMEM
);
544 state
->plane_states
[index
] = plane_state
;
545 state
->planes
[index
] = plane
;
546 plane_state
->state
= state
;
548 DRM_DEBUG_ATOMIC("Added [PLANE:%d] %p state to %p\n",
549 plane
->base
.id
, plane_state
, state
);
551 if (plane_state
->crtc
) {
552 struct drm_crtc_state
*crtc_state
;
554 crtc_state
= drm_atomic_get_crtc_state(state
,
556 if (IS_ERR(crtc_state
))
557 return ERR_CAST(crtc_state
);
562 EXPORT_SYMBOL(drm_atomic_get_plane_state
);
565 * drm_atomic_plane_set_property - set property on plane
566 * @plane: the drm plane to set a property on
567 * @state: the state object to update with the new property value
568 * @property: the property to set
569 * @val: the new property value
571 * Use this instead of calling plane->atomic_set_property directly.
572 * This function handles generic/core properties and calls out to
573 * driver's ->atomic_set_property() for driver properties. To ensure
574 * consistent behavior you must call this function rather than the
575 * driver hook directly.
578 * Zero on success, error code on failure
580 int drm_atomic_plane_set_property(struct drm_plane
*plane
,
581 struct drm_plane_state
*state
, struct drm_property
*property
,
584 struct drm_device
*dev
= plane
->dev
;
585 struct drm_mode_config
*config
= &dev
->mode_config
;
587 if (property
== config
->prop_fb_id
) {
588 struct drm_framebuffer
*fb
= drm_framebuffer_lookup(dev
, val
);
589 drm_atomic_set_fb_for_plane(state
, fb
);
591 drm_framebuffer_unreference(fb
);
592 } else if (property
== config
->prop_crtc_id
) {
593 struct drm_crtc
*crtc
= drm_crtc_find(dev
, val
);
594 return drm_atomic_set_crtc_for_plane(state
, crtc
);
595 } else if (property
== config
->prop_crtc_x
) {
596 state
->crtc_x
= U642I64(val
);
597 } else if (property
== config
->prop_crtc_y
) {
598 state
->crtc_y
= U642I64(val
);
599 } else if (property
== config
->prop_crtc_w
) {
601 } else if (property
== config
->prop_crtc_h
) {
603 } else if (property
== config
->prop_src_x
) {
605 } else if (property
== config
->prop_src_y
) {
607 } else if (property
== config
->prop_src_w
) {
609 } else if (property
== config
->prop_src_h
) {
611 } else if (property
== config
->rotation_property
) {
612 state
->rotation
= val
;
613 } else if (plane
->funcs
->atomic_set_property
) {
614 return plane
->funcs
->atomic_set_property(plane
, state
,
622 EXPORT_SYMBOL(drm_atomic_plane_set_property
);
625 * This function handles generic/core properties and calls out to
626 * driver's ->atomic_get_property() for driver properties. To ensure
627 * consistent behavior you must call this function rather than the
628 * driver hook directly.
631 drm_atomic_plane_get_property(struct drm_plane
*plane
,
632 const struct drm_plane_state
*state
,
633 struct drm_property
*property
, uint64_t *val
)
635 struct drm_device
*dev
= plane
->dev
;
636 struct drm_mode_config
*config
= &dev
->mode_config
;
638 if (property
== config
->prop_fb_id
) {
639 *val
= (state
->fb
) ? state
->fb
->base
.id
: 0;
640 } else if (property
== config
->prop_crtc_id
) {
641 *val
= (state
->crtc
) ? state
->crtc
->base
.id
: 0;
642 } else if (property
== config
->prop_crtc_x
) {
643 *val
= I642U64(state
->crtc_x
);
644 } else if (property
== config
->prop_crtc_y
) {
645 *val
= I642U64(state
->crtc_y
);
646 } else if (property
== config
->prop_crtc_w
) {
647 *val
= state
->crtc_w
;
648 } else if (property
== config
->prop_crtc_h
) {
649 *val
= state
->crtc_h
;
650 } else if (property
== config
->prop_src_x
) {
652 } else if (property
== config
->prop_src_y
) {
654 } else if (property
== config
->prop_src_w
) {
656 } else if (property
== config
->prop_src_h
) {
658 } else if (property
== config
->rotation_property
) {
659 *val
= state
->rotation
;
660 } else if (plane
->funcs
->atomic_get_property
) {
661 return plane
->funcs
->atomic_get_property(plane
, state
, property
, val
);
670 plane_switching_crtc(struct drm_atomic_state
*state
,
671 struct drm_plane
*plane
,
672 struct drm_plane_state
*plane_state
)
674 if (!plane
->state
->crtc
|| !plane_state
->crtc
)
677 if (plane
->state
->crtc
== plane_state
->crtc
)
680 /* This could be refined, but currently there's no helper or driver code
681 * to implement direct switching of active planes nor userspace to take
682 * advantage of more direct plane switching without the intermediate
689 * drm_atomic_plane_check - check plane state
690 * @plane: plane to check
691 * @state: plane state to check
693 * Provides core sanity checks for plane state.
696 * Zero on success, error code on failure
698 static int drm_atomic_plane_check(struct drm_plane
*plane
,
699 struct drm_plane_state
*state
)
701 unsigned int fb_width
, fb_height
;
704 /* either *both* CRTC and FB must be set, or neither */
705 if (WARN_ON(state
->crtc
&& !state
->fb
)) {
706 DRM_DEBUG_ATOMIC("CRTC set but no FB\n");
708 } else if (WARN_ON(state
->fb
&& !state
->crtc
)) {
709 DRM_DEBUG_ATOMIC("FB set but no CRTC\n");
713 /* if disabled, we don't care about the rest of the state: */
717 /* Check whether this plane is usable on this CRTC */
718 if (!(plane
->possible_crtcs
& drm_crtc_mask(state
->crtc
))) {
719 DRM_DEBUG_ATOMIC("Invalid crtc for plane\n");
723 /* Check whether this plane supports the fb pixel format. */
724 ret
= drm_plane_check_pixel_format(plane
, state
->fb
->pixel_format
);
726 DRM_DEBUG_ATOMIC("Invalid pixel format %s\n",
727 drm_get_format_name(state
->fb
->pixel_format
));
731 /* Give drivers some help against integer overflows */
732 if (state
->crtc_w
> INT_MAX
||
733 state
->crtc_x
> INT_MAX
- (int32_t) state
->crtc_w
||
734 state
->crtc_h
> INT_MAX
||
735 state
->crtc_y
> INT_MAX
- (int32_t) state
->crtc_h
) {
736 DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n",
737 state
->crtc_w
, state
->crtc_h
,
738 state
->crtc_x
, state
->crtc_y
);
742 fb_width
= state
->fb
->width
<< 16;
743 fb_height
= state
->fb
->height
<< 16;
745 /* Make sure source coordinates are inside the fb. */
746 if (state
->src_w
> fb_width
||
747 state
->src_x
> fb_width
- state
->src_w
||
748 state
->src_h
> fb_height
||
749 state
->src_y
> fb_height
- state
->src_h
) {
750 DRM_DEBUG_ATOMIC("Invalid source coordinates "
751 "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
752 state
->src_w
>> 16, ((state
->src_w
& 0xffff) * 15625) >> 10,
753 state
->src_h
>> 16, ((state
->src_h
& 0xffff) * 15625) >> 10,
754 state
->src_x
>> 16, ((state
->src_x
& 0xffff) * 15625) >> 10,
755 state
->src_y
>> 16, ((state
->src_y
& 0xffff) * 15625) >> 10);
759 if (plane_switching_crtc(state
->state
, plane
, state
)) {
760 DRM_DEBUG_ATOMIC("[PLANE:%d] switching CRTC directly\n",
769 * drm_atomic_get_connector_state - get connector state
770 * @state: global atomic state object
771 * @connector: connector to get state object for
773 * This function returns the connector state for the given connector,
774 * allocating it if needed. It will also grab the relevant connector lock to
775 * make sure that the state is consistent.
779 * Either the allocated state or the error code encoded into the pointer. When
780 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
781 * entire atomic sequence must be restarted. All other errors are fatal.
783 struct drm_connector_state
*
784 drm_atomic_get_connector_state(struct drm_atomic_state
*state
,
785 struct drm_connector
*connector
)
788 struct drm_mode_config
*config
= &connector
->dev
->mode_config
;
789 struct drm_connector_state
*connector_state
;
791 ret
= drm_modeset_lock(&config
->connection_mutex
, state
->acquire_ctx
);
795 index
= drm_connector_index(connector
);
798 * Construction of atomic state updates can race with a connector
799 * hot-add which might overflow. In this case flip the table and just
800 * restart the entire ioctl - no one is fast enough to livelock a cpu
801 * with physical hotplug events anyway.
803 * Note that we only grab the indexes once we have the right lock to
804 * prevent hotplug/unplugging of connectors. So removal is no problem,
805 * at most the array is a bit too large.
807 if (index
>= state
->num_connector
) {
808 DRM_DEBUG_ATOMIC("Hot-added connector would overflow state array, restarting\n");
809 return ERR_PTR(-EAGAIN
);
812 if (state
->connector_states
[index
])
813 return state
->connector_states
[index
];
815 connector_state
= connector
->funcs
->atomic_duplicate_state(connector
);
816 if (!connector_state
)
817 return ERR_PTR(-ENOMEM
);
819 state
->connector_states
[index
] = connector_state
;
820 state
->connectors
[index
] = connector
;
821 connector_state
->state
= state
;
823 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d] %p state to %p\n",
824 connector
->base
.id
, connector_state
, state
);
826 if (connector_state
->crtc
) {
827 struct drm_crtc_state
*crtc_state
;
829 crtc_state
= drm_atomic_get_crtc_state(state
,
830 connector_state
->crtc
);
831 if (IS_ERR(crtc_state
))
832 return ERR_CAST(crtc_state
);
835 return connector_state
;
837 EXPORT_SYMBOL(drm_atomic_get_connector_state
);
840 * drm_atomic_connector_set_property - set property on connector.
841 * @connector: the drm connector to set a property on
842 * @state: the state object to update with the new property value
843 * @property: the property to set
844 * @val: the new property value
846 * Use this instead of calling connector->atomic_set_property directly.
847 * This function handles generic/core properties and calls out to
848 * driver's ->atomic_set_property() for driver properties. To ensure
849 * consistent behavior you must call this function rather than the
850 * driver hook directly.
853 * Zero on success, error code on failure
855 int drm_atomic_connector_set_property(struct drm_connector
*connector
,
856 struct drm_connector_state
*state
, struct drm_property
*property
,
859 struct drm_device
*dev
= connector
->dev
;
860 struct drm_mode_config
*config
= &dev
->mode_config
;
862 if (property
== config
->prop_crtc_id
) {
863 struct drm_crtc
*crtc
= drm_crtc_find(dev
, val
);
864 return drm_atomic_set_crtc_for_connector(state
, crtc
);
865 } else if (property
== config
->dpms_property
) {
866 /* setting DPMS property requires special handling, which
867 * is done in legacy setprop path for us. Disallow (for
868 * now?) atomic writes to DPMS property:
871 } else if (connector
->funcs
->atomic_set_property
) {
872 return connector
->funcs
->atomic_set_property(connector
,
873 state
, property
, val
);
878 EXPORT_SYMBOL(drm_atomic_connector_set_property
);
881 * This function handles generic/core properties and calls out to
882 * driver's ->atomic_get_property() for driver properties. To ensure
883 * consistent behavior you must call this function rather than the
884 * driver hook directly.
887 drm_atomic_connector_get_property(struct drm_connector
*connector
,
888 const struct drm_connector_state
*state
,
889 struct drm_property
*property
, uint64_t *val
)
891 struct drm_device
*dev
= connector
->dev
;
892 struct drm_mode_config
*config
= &dev
->mode_config
;
894 if (property
== config
->prop_crtc_id
) {
895 *val
= (state
->crtc
) ? state
->crtc
->base
.id
: 0;
896 } else if (property
== config
->dpms_property
) {
897 *val
= connector
->dpms
;
898 } else if (connector
->funcs
->atomic_get_property
) {
899 return connector
->funcs
->atomic_get_property(connector
,
900 state
, property
, val
);
908 int drm_atomic_get_property(struct drm_mode_object
*obj
,
909 struct drm_property
*property
, uint64_t *val
)
911 struct drm_device
*dev
= property
->dev
;
915 case DRM_MODE_OBJECT_CONNECTOR
: {
916 struct drm_connector
*connector
= obj_to_connector(obj
);
917 WARN_ON(!drm_modeset_is_locked(&dev
->mode_config
.connection_mutex
));
918 ret
= drm_atomic_connector_get_property(connector
,
919 connector
->state
, property
, val
);
922 case DRM_MODE_OBJECT_CRTC
: {
923 struct drm_crtc
*crtc
= obj_to_crtc(obj
);
924 WARN_ON(!drm_modeset_is_locked(&crtc
->mutex
));
925 ret
= drm_atomic_crtc_get_property(crtc
,
926 crtc
->state
, property
, val
);
929 case DRM_MODE_OBJECT_PLANE
: {
930 struct drm_plane
*plane
= obj_to_plane(obj
);
931 WARN_ON(!drm_modeset_is_locked(&plane
->mutex
));
932 ret
= drm_atomic_plane_get_property(plane
,
933 plane
->state
, property
, val
);
945 * drm_atomic_set_crtc_for_plane - set crtc for plane
946 * @plane_state: the plane whose incoming state to update
947 * @crtc: crtc to use for the plane
949 * Changing the assigned crtc for a plane requires us to grab the lock and state
950 * for the new crtc, as needed. This function takes care of all these details
951 * besides updating the pointer in the state object itself.
954 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
955 * then the w/w mutex code has detected a deadlock and the entire atomic
956 * sequence must be restarted. All other errors are fatal.
959 drm_atomic_set_crtc_for_plane(struct drm_plane_state
*plane_state
,
960 struct drm_crtc
*crtc
)
962 struct drm_plane
*plane
= plane_state
->plane
;
963 struct drm_crtc_state
*crtc_state
;
965 if (plane_state
->crtc
) {
966 crtc_state
= drm_atomic_get_crtc_state(plane_state
->state
,
968 if (WARN_ON(IS_ERR(crtc_state
)))
969 return PTR_ERR(crtc_state
);
971 crtc_state
->plane_mask
&= ~(1 << drm_plane_index(plane
));
974 plane_state
->crtc
= crtc
;
977 crtc_state
= drm_atomic_get_crtc_state(plane_state
->state
,
979 if (IS_ERR(crtc_state
))
980 return PTR_ERR(crtc_state
);
981 crtc_state
->plane_mask
|= (1 << drm_plane_index(plane
));
985 DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d]\n",
986 plane_state
, crtc
->base
.id
);
988 DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n",
993 EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane
);
996 * drm_atomic_set_fb_for_plane - set framebuffer for plane
997 * @plane_state: atomic state object for the plane
998 * @fb: fb to use for the plane
1000 * Changing the assigned framebuffer for a plane requires us to grab a reference
1001 * to the new fb and drop the reference to the old fb, if there is one. This
1002 * function takes care of all these details besides updating the pointer in the
1003 * state object itself.
1006 drm_atomic_set_fb_for_plane(struct drm_plane_state
*plane_state
,
1007 struct drm_framebuffer
*fb
)
1009 if (plane_state
->fb
)
1010 drm_framebuffer_unreference(plane_state
->fb
);
1012 drm_framebuffer_reference(fb
);
1013 plane_state
->fb
= fb
;
1016 DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n",
1017 fb
->base
.id
, plane_state
);
1019 DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n",
1022 EXPORT_SYMBOL(drm_atomic_set_fb_for_plane
);
1025 * drm_atomic_set_crtc_for_connector - set crtc for connector
1026 * @conn_state: atomic state object for the connector
1027 * @crtc: crtc to use for the connector
1029 * Changing the assigned crtc for a connector requires us to grab the lock and
1030 * state for the new crtc, as needed. This function takes care of all these
1031 * details besides updating the pointer in the state object itself.
1034 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1035 * then the w/w mutex code has detected a deadlock and the entire atomic
1036 * sequence must be restarted. All other errors are fatal.
1039 drm_atomic_set_crtc_for_connector(struct drm_connector_state
*conn_state
,
1040 struct drm_crtc
*crtc
)
1042 struct drm_crtc_state
*crtc_state
;
1045 crtc_state
= drm_atomic_get_crtc_state(conn_state
->state
, crtc
);
1046 if (IS_ERR(crtc_state
))
1047 return PTR_ERR(crtc_state
);
1050 conn_state
->crtc
= crtc
;
1053 DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d]\n",
1054 conn_state
, crtc
->base
.id
);
1056 DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n",
1061 EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector
);
1064 * drm_atomic_add_affected_connectors - add connectors for crtc
1065 * @state: atomic state
1068 * This function walks the current configuration and adds all connectors
1069 * currently using @crtc to the atomic configuration @state. Note that this
1070 * function must acquire the connection mutex. This can potentially cause
1071 * unneeded seralization if the update is just for the planes on one crtc. Hence
1072 * drivers and helpers should only call this when really needed (e.g. when a
1073 * full modeset needs to happen due to some change).
1076 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1077 * then the w/w mutex code has detected a deadlock and the entire atomic
1078 * sequence must be restarted. All other errors are fatal.
1081 drm_atomic_add_affected_connectors(struct drm_atomic_state
*state
,
1082 struct drm_crtc
*crtc
)
1084 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1085 struct drm_connector
*connector
;
1086 struct drm_connector_state
*conn_state
;
1089 ret
= drm_modeset_lock(&config
->connection_mutex
, state
->acquire_ctx
);
1093 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d] to %p\n",
1094 crtc
->base
.id
, state
);
1097 * Changed connectors are already in @state, so only need to look at the
1098 * current configuration.
1100 drm_for_each_connector(connector
, state
->dev
) {
1101 if (connector
->state
->crtc
!= crtc
)
1104 conn_state
= drm_atomic_get_connector_state(state
, connector
);
1105 if (IS_ERR(conn_state
))
1106 return PTR_ERR(conn_state
);
1111 EXPORT_SYMBOL(drm_atomic_add_affected_connectors
);
1114 * drm_atomic_add_affected_planes - add planes for crtc
1115 * @state: atomic state
1118 * This function walks the current configuration and adds all planes
1119 * currently used by @crtc to the atomic configuration @state. This is useful
1120 * when an atomic commit also needs to check all currently enabled plane on
1121 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1122 * to avoid special code to force-enable all planes.
1124 * Since acquiring a plane state will always also acquire the w/w mutex of the
1125 * current CRTC for that plane (if there is any) adding all the plane states for
1126 * a CRTC will not reduce parallism of atomic updates.
1129 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1130 * then the w/w mutex code has detected a deadlock and the entire atomic
1131 * sequence must be restarted. All other errors are fatal.
1134 drm_atomic_add_affected_planes(struct drm_atomic_state
*state
,
1135 struct drm_crtc
*crtc
)
1137 struct drm_plane
*plane
;
1139 WARN_ON(!drm_atomic_get_existing_crtc_state(state
, crtc
));
1141 drm_for_each_plane_mask(plane
, state
->dev
, crtc
->state
->plane_mask
) {
1142 struct drm_plane_state
*plane_state
=
1143 drm_atomic_get_plane_state(state
, plane
);
1145 if (IS_ERR(plane_state
))
1146 return PTR_ERR(plane_state
);
1150 EXPORT_SYMBOL(drm_atomic_add_affected_planes
);
1153 * drm_atomic_connectors_for_crtc - count number of connected outputs
1154 * @state: atomic state
1157 * This function counts all connectors which will be connected to @crtc
1158 * according to @state. Useful to recompute the enable state for @crtc.
1161 drm_atomic_connectors_for_crtc(struct drm_atomic_state
*state
,
1162 struct drm_crtc
*crtc
)
1164 struct drm_connector
*connector
;
1165 struct drm_connector_state
*conn_state
;
1167 int i
, num_connected_connectors
= 0;
1169 for_each_connector_in_state(state
, connector
, conn_state
, i
) {
1170 if (conn_state
->crtc
== crtc
)
1171 num_connected_connectors
++;
1174 DRM_DEBUG_ATOMIC("State %p has %i connectors for [CRTC:%d]\n",
1175 state
, num_connected_connectors
, crtc
->base
.id
);
1177 return num_connected_connectors
;
1179 EXPORT_SYMBOL(drm_atomic_connectors_for_crtc
);
1182 * drm_atomic_legacy_backoff - locking backoff for legacy ioctls
1183 * @state: atomic state
1185 * This function should be used by legacy entry points which don't understand
1186 * -EDEADLK semantics. For simplicity this one will grab all modeset locks after
1187 * the slowpath completed.
1189 void drm_atomic_legacy_backoff(struct drm_atomic_state
*state
)
1194 drm_modeset_backoff(state
->acquire_ctx
);
1196 ret
= drm_modeset_lock(&state
->dev
->mode_config
.connection_mutex
,
1197 state
->acquire_ctx
);
1200 ret
= drm_modeset_lock_all_crtcs(state
->dev
,
1201 state
->acquire_ctx
);
1205 EXPORT_SYMBOL(drm_atomic_legacy_backoff
);
1208 * drm_atomic_check_only - check whether a given config would work
1209 * @state: atomic configuration to check
1211 * Note that this function can return -EDEADLK if the driver needed to acquire
1212 * more locks but encountered a deadlock. The caller must then do the usual w/w
1213 * backoff dance and restart. All other errors are fatal.
1216 * 0 on success, negative error code on failure.
1218 int drm_atomic_check_only(struct drm_atomic_state
*state
)
1220 struct drm_device
*dev
= state
->dev
;
1221 struct drm_mode_config
*config
= &dev
->mode_config
;
1222 struct drm_plane
*plane
;
1223 struct drm_plane_state
*plane_state
;
1224 struct drm_crtc
*crtc
;
1225 struct drm_crtc_state
*crtc_state
;
1228 DRM_DEBUG_ATOMIC("checking %p\n", state
);
1230 for_each_plane_in_state(state
, plane
, plane_state
, i
) {
1231 ret
= drm_atomic_plane_check(plane
, plane_state
);
1233 DRM_DEBUG_ATOMIC("[PLANE:%d] atomic core check failed\n",
1239 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1240 ret
= drm_atomic_crtc_check(crtc
, crtc_state
);
1242 DRM_DEBUG_ATOMIC("[CRTC:%d] atomic core check failed\n",
1248 if (config
->funcs
->atomic_check
)
1249 ret
= config
->funcs
->atomic_check(state
->dev
, state
);
1251 if (!state
->allow_modeset
) {
1252 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1253 if (drm_atomic_crtc_needs_modeset(crtc_state
)) {
1254 DRM_DEBUG_ATOMIC("[CRTC:%d] requires full modeset\n",
1263 EXPORT_SYMBOL(drm_atomic_check_only
);
1266 * drm_atomic_commit - commit configuration atomically
1267 * @state: atomic configuration to check
1269 * Note that this function can return -EDEADLK if the driver needed to acquire
1270 * more locks but encountered a deadlock. The caller must then do the usual w/w
1271 * backoff dance and restart. All other errors are fatal.
1273 * Also note that on successful execution ownership of @state is transferred
1274 * from the caller of this function to the function itself. The caller must not
1275 * free or in any other way access @state. If the function fails then the caller
1276 * must clean up @state itself.
1279 * 0 on success, negative error code on failure.
1281 int drm_atomic_commit(struct drm_atomic_state
*state
)
1283 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1286 ret
= drm_atomic_check_only(state
);
1290 DRM_DEBUG_ATOMIC("commiting %p\n", state
);
1292 return config
->funcs
->atomic_commit(state
->dev
, state
, false);
1294 EXPORT_SYMBOL(drm_atomic_commit
);
1297 * drm_atomic_async_commit - atomic&async configuration commit
1298 * @state: atomic configuration to check
1300 * Note that this function can return -EDEADLK if the driver needed to acquire
1301 * more locks but encountered a deadlock. The caller must then do the usual w/w
1302 * backoff dance and restart. All other errors are fatal.
1304 * Also note that on successful execution ownership of @state is transferred
1305 * from the caller of this function to the function itself. The caller must not
1306 * free or in any other way access @state. If the function fails then the caller
1307 * must clean up @state itself.
1310 * 0 on success, negative error code on failure.
1312 int drm_atomic_async_commit(struct drm_atomic_state
*state
)
1314 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1317 ret
= drm_atomic_check_only(state
);
1321 DRM_DEBUG_ATOMIC("commiting %p asynchronously\n", state
);
1323 return config
->funcs
->atomic_commit(state
->dev
, state
, true);
1325 EXPORT_SYMBOL(drm_atomic_async_commit
);
1327 #ifdef __DragonFly__
1329 * The Linux layer version of kfree() is a macro and can't be called
1330 * directly via a function pointer
1333 drm_atomic_event_destroy(struct drm_pending_event
*e
)
1340 * The big monstor ioctl
1343 static struct drm_pending_vblank_event
*create_vblank_event(
1344 struct drm_device
*dev
, struct drm_file
*file_priv
, uint64_t user_data
)
1346 struct drm_pending_vblank_event
*e
= NULL
;
1347 unsigned long flags
;
1349 spin_lock_irqsave(&dev
->event_lock
, flags
);
1350 if (file_priv
->event_space
< sizeof e
->event
) {
1351 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
1354 file_priv
->event_space
-= sizeof e
->event
;
1355 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
1357 e
= kzalloc(sizeof *e
, GFP_KERNEL
);
1359 spin_lock_irqsave(&dev
->event_lock
, flags
);
1360 file_priv
->event_space
+= sizeof e
->event
;
1361 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
1365 e
->event
.base
.type
= DRM_EVENT_FLIP_COMPLETE
;
1366 e
->event
.base
.length
= sizeof e
->event
;
1367 e
->event
.user_data
= user_data
;
1368 e
->base
.event
= &e
->event
.base
;
1369 e
->base
.file_priv
= file_priv
;
1370 #ifdef __DragonFly__
1371 e
->base
.destroy
= drm_atomic_event_destroy
;
1373 e
->base
.destroy
= (void (*) (struct drm_pending_event
*)) kfree
;
1380 static void destroy_vblank_event(struct drm_device
*dev
,
1381 struct drm_file
*file_priv
, struct drm_pending_vblank_event
*e
)
1383 unsigned long flags
;
1385 spin_lock_irqsave(&dev
->event_lock
, flags
);
1386 file_priv
->event_space
+= sizeof e
->event
;
1387 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
1391 static int atomic_set_prop(struct drm_atomic_state
*state
,
1392 struct drm_mode_object
*obj
, struct drm_property
*prop
,
1393 uint64_t prop_value
)
1395 struct drm_mode_object
*ref
;
1398 if (!drm_property_change_valid_get(prop
, prop_value
, &ref
))
1401 switch (obj
->type
) {
1402 case DRM_MODE_OBJECT_CONNECTOR
: {
1403 struct drm_connector
*connector
= obj_to_connector(obj
);
1404 struct drm_connector_state
*connector_state
;
1406 connector_state
= drm_atomic_get_connector_state(state
, connector
);
1407 if (IS_ERR(connector_state
)) {
1408 ret
= PTR_ERR(connector_state
);
1412 ret
= drm_atomic_connector_set_property(connector
,
1413 connector_state
, prop
, prop_value
);
1416 case DRM_MODE_OBJECT_CRTC
: {
1417 struct drm_crtc
*crtc
= obj_to_crtc(obj
);
1418 struct drm_crtc_state
*crtc_state
;
1420 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
1421 if (IS_ERR(crtc_state
)) {
1422 ret
= PTR_ERR(crtc_state
);
1426 ret
= drm_atomic_crtc_set_property(crtc
,
1427 crtc_state
, prop
, prop_value
);
1430 case DRM_MODE_OBJECT_PLANE
: {
1431 struct drm_plane
*plane
= obj_to_plane(obj
);
1432 struct drm_plane_state
*plane_state
;
1434 plane_state
= drm_atomic_get_plane_state(state
, plane
);
1435 if (IS_ERR(plane_state
)) {
1436 ret
= PTR_ERR(plane_state
);
1440 ret
= drm_atomic_plane_set_property(plane
,
1441 plane_state
, prop
, prop_value
);
1449 drm_property_change_valid_put(prop
, ref
);
1454 * drm_atomic_update_old_fb -- Unset old_fb pointers and set plane->fb pointers.
1456 * @dev: drm device to check.
1457 * @plane_mask: plane mask for planes that were updated.
1458 * @ret: return value, can be -EDEADLK for a retry.
1460 * Before doing an update plane->old_fb is set to plane->fb,
1461 * but before dropping the locks old_fb needs to be set to NULL
1462 * and plane->fb updated. This is a common operation for each
1463 * atomic update, so this call is split off as a helper.
1465 void drm_atomic_clean_old_fb(struct drm_device
*dev
,
1466 unsigned plane_mask
,
1469 struct drm_plane
*plane
;
1471 /* if succeeded, fixup legacy plane crtc/fb ptrs before dropping
1472 * locks (ie. while it is still safe to deref plane->state). We
1473 * need to do this here because the driver entry points cannot
1474 * distinguish between legacy and atomic ioctls.
1476 drm_for_each_plane_mask(plane
, dev
, plane_mask
) {
1478 struct drm_framebuffer
*new_fb
= plane
->state
->fb
;
1480 drm_framebuffer_reference(new_fb
);
1482 plane
->crtc
= plane
->state
->crtc
;
1485 drm_framebuffer_unreference(plane
->old_fb
);
1487 plane
->old_fb
= NULL
;
1490 EXPORT_SYMBOL(drm_atomic_clean_old_fb
);
1492 int drm_mode_atomic_ioctl(struct drm_device
*dev
,
1493 void *data
, struct drm_file
*file_priv
)
1495 struct drm_mode_atomic
*arg
= data
;
1496 uint32_t __user
*objs_ptr
= (uint32_t __user
*)(unsigned long)(arg
->objs_ptr
);
1497 uint32_t __user
*count_props_ptr
= (uint32_t __user
*)(unsigned long)(arg
->count_props_ptr
);
1498 uint32_t __user
*props_ptr
= (uint32_t __user
*)(unsigned long)(arg
->props_ptr
);
1499 uint64_t __user
*prop_values_ptr
= (uint64_t __user
*)(unsigned long)(arg
->prop_values_ptr
);
1500 unsigned int copied_objs
, copied_props
;
1501 struct drm_atomic_state
*state
;
1502 struct drm_modeset_acquire_ctx ctx
;
1503 struct drm_plane
*plane
;
1504 struct drm_crtc
*crtc
;
1505 struct drm_crtc_state
*crtc_state
;
1506 unsigned plane_mask
;
1510 /* disallow for drivers not supporting atomic: */
1511 if (!drm_core_check_feature(dev
, DRIVER_ATOMIC
))
1514 /* disallow for userspace that has not enabled atomic cap (even
1515 * though this may be a bit overkill, since legacy userspace
1516 * wouldn't know how to call this ioctl)
1518 if (!file_priv
->atomic
)
1521 if (arg
->flags
& ~DRM_MODE_ATOMIC_FLAGS
)
1527 if ((arg
->flags
& DRM_MODE_PAGE_FLIP_ASYNC
) &&
1528 !dev
->mode_config
.async_page_flip
)
1531 /* can't test and expect an event at the same time. */
1532 if ((arg
->flags
& DRM_MODE_ATOMIC_TEST_ONLY
) &&
1533 (arg
->flags
& DRM_MODE_PAGE_FLIP_EVENT
))
1536 drm_modeset_acquire_init(&ctx
, 0);
1538 state
= drm_atomic_state_alloc(dev
);
1542 state
->acquire_ctx
= &ctx
;
1543 state
->allow_modeset
= !!(arg
->flags
& DRM_MODE_ATOMIC_ALLOW_MODESET
);
1550 for (i
= 0; i
< arg
->count_objs
; i
++) {
1551 uint32_t obj_id
, count_props
;
1552 struct drm_mode_object
*obj
;
1554 if (get_user(obj_id
, objs_ptr
+ copied_objs
)) {
1559 obj
= drm_mode_object_find(dev
, obj_id
, DRM_MODE_OBJECT_ANY
);
1560 if (!obj
|| !obj
->properties
) {
1565 if (get_user(count_props
, count_props_ptr
+ copied_objs
)) {
1572 for (j
= 0; j
< count_props
; j
++) {
1574 uint64_t prop_value
;
1575 struct drm_property
*prop
;
1577 if (get_user(prop_id
, props_ptr
+ copied_props
)) {
1582 prop
= drm_property_find(dev
, prop_id
);
1588 if (copy_from_user(&prop_value
,
1589 prop_values_ptr
+ copied_props
,
1590 sizeof(prop_value
))) {
1595 ret
= atomic_set_prop(state
, obj
, prop
, prop_value
);
1602 if (obj
->type
== DRM_MODE_OBJECT_PLANE
&& count_props
&&
1603 !(arg
->flags
& DRM_MODE_ATOMIC_TEST_ONLY
)) {
1604 plane
= obj_to_plane(obj
);
1605 plane_mask
|= (1 << drm_plane_index(plane
));
1606 plane
->old_fb
= plane
->fb
;
1610 if (arg
->flags
& DRM_MODE_PAGE_FLIP_EVENT
) {
1611 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1612 struct drm_pending_vblank_event
*e
;
1614 e
= create_vblank_event(dev
, file_priv
, arg
->user_data
);
1620 crtc_state
->event
= e
;
1624 if (arg
->flags
& DRM_MODE_ATOMIC_TEST_ONLY
) {
1626 * Unlike commit, check_only does not clean up state.
1627 * Below we call drm_atomic_state_free for it.
1629 ret
= drm_atomic_check_only(state
);
1630 } else if (arg
->flags
& DRM_MODE_ATOMIC_NONBLOCK
) {
1631 ret
= drm_atomic_async_commit(state
);
1633 ret
= drm_atomic_commit(state
);
1637 drm_atomic_clean_old_fb(dev
, plane_mask
, ret
);
1639 if (ret
&& arg
->flags
& DRM_MODE_PAGE_FLIP_EVENT
) {
1641 * TEST_ONLY and PAGE_FLIP_EVENT are mutually exclusive,
1642 * if they weren't, this code should be called on success
1643 * for TEST_ONLY too.
1646 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1647 if (!crtc_state
->event
)
1650 destroy_vblank_event(dev
, file_priv
,
1655 if (ret
== -EDEADLK
) {
1656 drm_atomic_state_clear(state
);
1657 drm_modeset_backoff(&ctx
);
1661 if (ret
|| arg
->flags
& DRM_MODE_ATOMIC_TEST_ONLY
)
1662 drm_atomic_state_free(state
);
1664 drm_modeset_drop_locks(&ctx
);
1665 drm_modeset_acquire_fini(&ctx
);