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_mode.h>
32 #include <drm/drm_plane_helper.h>
34 #include "drm_crtc_internal.h"
37 * drm_atomic_state_default_release -
38 * release memory initialized by drm_atomic_state_init
39 * @state: atomic state
41 * Free all the memory allocated by drm_atomic_state_init.
42 * This is useful for drivers that subclass the atomic state.
44 void drm_atomic_state_default_release(struct drm_atomic_state
*state
)
46 kfree(state
->connectors
);
47 kfree(state
->connector_states
);
49 kfree(state
->crtc_states
);
51 kfree(state
->plane_states
);
53 EXPORT_SYMBOL(drm_atomic_state_default_release
);
56 * drm_atomic_state_init - init new atomic state
58 * @state: atomic state
60 * Default implementation for filling in a new atomic state.
61 * This is useful for drivers that subclass the atomic state.
64 drm_atomic_state_init(struct drm_device
*dev
, struct drm_atomic_state
*state
)
66 /* TODO legacy paths should maybe do a better job about
67 * setting this appropriately?
69 state
->allow_modeset
= true;
71 state
->crtcs
= kcalloc(dev
->mode_config
.num_crtc
,
72 sizeof(*state
->crtcs
), GFP_KERNEL
);
75 state
->crtc_states
= kcalloc(dev
->mode_config
.num_crtc
,
76 sizeof(*state
->crtc_states
), GFP_KERNEL
);
77 if (!state
->crtc_states
)
79 state
->planes
= kcalloc(dev
->mode_config
.num_total_plane
,
80 sizeof(*state
->planes
), GFP_KERNEL
);
83 state
->plane_states
= kcalloc(dev
->mode_config
.num_total_plane
,
84 sizeof(*state
->plane_states
), GFP_KERNEL
);
85 if (!state
->plane_states
)
90 DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state
);
94 drm_atomic_state_default_release(state
);
97 EXPORT_SYMBOL(drm_atomic_state_init
);
100 * drm_atomic_state_alloc - allocate atomic state
103 * This allocates an empty atomic state to track updates.
105 struct drm_atomic_state
*
106 drm_atomic_state_alloc(struct drm_device
*dev
)
108 struct drm_mode_config
*config
= &dev
->mode_config
;
109 struct drm_atomic_state
*state
;
111 if (!config
->funcs
->atomic_state_alloc
) {
112 state
= kzalloc(sizeof(*state
), GFP_KERNEL
);
115 if (drm_atomic_state_init(dev
, state
) < 0) {
122 return config
->funcs
->atomic_state_alloc(dev
);
124 EXPORT_SYMBOL(drm_atomic_state_alloc
);
127 * drm_atomic_state_default_clear - clear base atomic state
128 * @state: atomic state
130 * Default implementation for clearing atomic state.
131 * This is useful for drivers that subclass the atomic state.
133 void drm_atomic_state_default_clear(struct drm_atomic_state
*state
)
135 struct drm_device
*dev
= state
->dev
;
136 struct drm_mode_config
*config
= &dev
->mode_config
;
139 DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state
);
141 for (i
= 0; i
< state
->num_connector
; i
++) {
142 struct drm_connector
*connector
= state
->connectors
[i
];
147 connector
->funcs
->atomic_destroy_state(connector
,
148 state
->connector_states
[i
]);
149 state
->connectors
[i
] = NULL
;
150 state
->connector_states
[i
] = NULL
;
151 drm_connector_unreference(connector
);
154 for (i
= 0; i
< config
->num_crtc
; i
++) {
155 struct drm_crtc
*crtc
= state
->crtcs
[i
];
160 crtc
->funcs
->atomic_destroy_state(crtc
,
161 state
->crtc_states
[i
]);
162 state
->crtcs
[i
] = NULL
;
163 state
->crtc_states
[i
] = NULL
;
166 for (i
= 0; i
< config
->num_total_plane
; i
++) {
167 struct drm_plane
*plane
= state
->planes
[i
];
172 plane
->funcs
->atomic_destroy_state(plane
,
173 state
->plane_states
[i
]);
174 state
->planes
[i
] = NULL
;
175 state
->plane_states
[i
] = NULL
;
178 EXPORT_SYMBOL(drm_atomic_state_default_clear
);
181 * drm_atomic_state_clear - clear state object
182 * @state: atomic state
184 * When the w/w mutex algorithm detects a deadlock we need to back off and drop
185 * all locks. So someone else could sneak in and change the current modeset
186 * configuration. Which means that all the state assembled in @state is no
187 * longer an atomic update to the current state, but to some arbitrary earlier
188 * state. Which could break assumptions the driver's ->atomic_check likely
191 * Hence we must clear all cached state and completely start over, using this
194 void drm_atomic_state_clear(struct drm_atomic_state
*state
)
196 struct drm_device
*dev
= state
->dev
;
197 struct drm_mode_config
*config
= &dev
->mode_config
;
199 if (config
->funcs
->atomic_state_clear
)
200 config
->funcs
->atomic_state_clear(state
);
202 drm_atomic_state_default_clear(state
);
204 EXPORT_SYMBOL(drm_atomic_state_clear
);
207 * drm_atomic_state_free - free all memory for an atomic state
208 * @state: atomic state to deallocate
210 * This frees all memory associated with an atomic state, including all the
211 * per-object state for planes, crtcs and connectors.
213 void drm_atomic_state_free(struct drm_atomic_state
*state
)
215 struct drm_device
*dev
;
216 struct drm_mode_config
*config
;
222 config
= &dev
->mode_config
;
224 drm_atomic_state_clear(state
);
226 DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state
);
228 if (config
->funcs
->atomic_state_free
) {
229 config
->funcs
->atomic_state_free(state
);
231 drm_atomic_state_default_release(state
);
235 EXPORT_SYMBOL(drm_atomic_state_free
);
238 * drm_atomic_get_crtc_state - get crtc state
239 * @state: global atomic state object
240 * @crtc: crtc to get state object for
242 * This function returns the crtc state for the given crtc, allocating it if
243 * needed. It will also grab the relevant crtc lock to make sure that the state
248 * Either the allocated state or the error code encoded into the pointer. When
249 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
250 * entire atomic sequence must be restarted. All other errors are fatal.
252 struct drm_crtc_state
*
253 drm_atomic_get_crtc_state(struct drm_atomic_state
*state
,
254 struct drm_crtc
*crtc
)
256 int ret
, index
= drm_crtc_index(crtc
);
257 struct drm_crtc_state
*crtc_state
;
259 WARN_ON(!state
->acquire_ctx
);
261 crtc_state
= drm_atomic_get_existing_crtc_state(state
, crtc
);
265 ret
= drm_modeset_lock(&crtc
->mutex
, state
->acquire_ctx
);
269 crtc_state
= crtc
->funcs
->atomic_duplicate_state(crtc
);
271 return ERR_PTR(-ENOMEM
);
273 state
->crtc_states
[index
] = crtc_state
;
274 state
->crtcs
[index
] = crtc
;
275 crtc_state
->state
= state
;
277 DRM_DEBUG_ATOMIC("Added [CRTC:%d:%s] %p state to %p\n",
278 crtc
->base
.id
, crtc
->name
, crtc_state
, state
);
282 EXPORT_SYMBOL(drm_atomic_get_crtc_state
);
285 * drm_atomic_set_mode_for_crtc - set mode for CRTC
286 * @state: the CRTC whose incoming state to update
287 * @mode: kernel-internal mode to use for the CRTC, or NULL to disable
289 * Set a mode (originating from the kernel) on the desired CRTC state. Does
290 * not change any other state properties, including enable, active, or
294 * Zero on success, error code on failure. Cannot return -EDEADLK.
296 int drm_atomic_set_mode_for_crtc(struct drm_crtc_state
*state
,
297 struct drm_display_mode
*mode
)
299 struct drm_mode_modeinfo umode
;
301 /* Early return for no change. */
302 if (mode
&& memcmp(&state
->mode
, mode
, sizeof(*mode
)) == 0)
305 drm_property_unreference_blob(state
->mode_blob
);
306 state
->mode_blob
= NULL
;
309 drm_mode_convert_to_umode(&umode
, mode
);
311 drm_property_create_blob(state
->crtc
->dev
,
314 if (IS_ERR(state
->mode_blob
))
315 return PTR_ERR(state
->mode_blob
);
317 drm_mode_copy(&state
->mode
, mode
);
318 state
->enable
= true;
319 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
322 memset(&state
->mode
, 0, sizeof(state
->mode
));
323 state
->enable
= false;
324 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
330 EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc
);
333 * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC
334 * @state: the CRTC whose incoming state to update
335 * @blob: pointer to blob property to use for mode
337 * Set a mode (originating from a blob property) on the desired CRTC state.
338 * This function will take a reference on the blob property for the CRTC state,
339 * and release the reference held on the state's existing mode property, if any
343 * Zero on success, error code on failure. Cannot return -EDEADLK.
345 int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state
*state
,
346 struct drm_property_blob
*blob
)
348 if (blob
== state
->mode_blob
)
351 drm_property_unreference_blob(state
->mode_blob
);
352 state
->mode_blob
= NULL
;
355 if (blob
->length
!= sizeof(struct drm_mode_modeinfo
) ||
356 drm_mode_convert_umode(&state
->mode
,
357 (const struct drm_mode_modeinfo
*)
361 state
->mode_blob
= drm_property_reference_blob(blob
);
362 state
->enable
= true;
363 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
364 state
->mode
.name
, state
);
366 memset(&state
->mode
, 0, sizeof(state
->mode
));
367 state
->enable
= false;
368 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
374 EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc
);
377 * drm_atomic_replace_property_blob - replace a blob property
378 * @blob: a pointer to the member blob to be replaced
379 * @new_blob: the new blob to replace with
380 * @replaced: whether the blob has been replaced
383 * Zero on success, error code on failure
386 drm_atomic_replace_property_blob(struct drm_property_blob
**blob
,
387 struct drm_property_blob
*new_blob
,
390 struct drm_property_blob
*old_blob
= *blob
;
392 if (old_blob
== new_blob
)
396 drm_property_unreference_blob(old_blob
);
398 drm_property_reference_blob(new_blob
);
406 drm_atomic_replace_property_blob_from_id(struct drm_crtc
*crtc
,
407 struct drm_property_blob
**blob
,
409 ssize_t expected_size
,
412 struct drm_device
*dev
= crtc
->dev
;
413 struct drm_property_blob
*new_blob
= NULL
;
416 new_blob
= drm_property_lookup_blob(dev
, blob_id
);
417 if (new_blob
== NULL
)
419 if (expected_size
> 0 && expected_size
!= new_blob
->length
)
423 drm_atomic_replace_property_blob(blob
, new_blob
, replaced
);
429 * drm_atomic_crtc_set_property - set property on CRTC
430 * @crtc: the drm CRTC to set a property on
431 * @state: the state object to update with the new property value
432 * @property: the property to set
433 * @val: the new property value
435 * Use this instead of calling crtc->atomic_set_property directly.
436 * This function handles generic/core properties and calls out to
437 * driver's ->atomic_set_property() for driver properties. To ensure
438 * consistent behavior you must call this function rather than the
439 * driver hook directly.
442 * Zero on success, error code on failure
444 int drm_atomic_crtc_set_property(struct drm_crtc
*crtc
,
445 struct drm_crtc_state
*state
, struct drm_property
*property
,
448 struct drm_device
*dev
= crtc
->dev
;
449 struct drm_mode_config
*config
= &dev
->mode_config
;
450 bool replaced
= false;
453 if (property
== config
->prop_active
)
455 else if (property
== config
->prop_mode_id
) {
456 struct drm_property_blob
*mode
=
457 drm_property_lookup_blob(dev
, val
);
458 ret
= drm_atomic_set_mode_prop_for_crtc(state
, mode
);
459 drm_property_unreference_blob(mode
);
461 } else if (property
== config
->degamma_lut_property
) {
462 ret
= drm_atomic_replace_property_blob_from_id(crtc
,
467 state
->color_mgmt_changed
= replaced
;
469 } else if (property
== config
->ctm_property
) {
470 ret
= drm_atomic_replace_property_blob_from_id(crtc
,
473 sizeof(struct drm_color_ctm
),
475 state
->color_mgmt_changed
= replaced
;
477 } else if (property
== config
->gamma_lut_property
) {
478 ret
= drm_atomic_replace_property_blob_from_id(crtc
,
483 state
->color_mgmt_changed
= replaced
;
485 } else if (crtc
->funcs
->atomic_set_property
)
486 return crtc
->funcs
->atomic_set_property(crtc
, state
, property
, val
);
492 EXPORT_SYMBOL(drm_atomic_crtc_set_property
);
495 * drm_atomic_crtc_get_property - get property value from CRTC state
496 * @crtc: the drm CRTC to set a property on
497 * @state: the state object to get the property value from
498 * @property: the property to set
499 * @val: return location for the property value
501 * This function handles generic/core properties and calls out to
502 * driver's ->atomic_get_property() for driver properties. To ensure
503 * consistent behavior you must call this function rather than the
504 * driver hook directly.
507 * Zero on success, error code on failure
510 drm_atomic_crtc_get_property(struct drm_crtc
*crtc
,
511 const struct drm_crtc_state
*state
,
512 struct drm_property
*property
, uint64_t *val
)
514 struct drm_device
*dev
= crtc
->dev
;
515 struct drm_mode_config
*config
= &dev
->mode_config
;
517 if (property
== config
->prop_active
)
518 *val
= state
->active
;
519 else if (property
== config
->prop_mode_id
)
520 *val
= (state
->mode_blob
) ? state
->mode_blob
->base
.id
: 0;
521 else if (property
== config
->degamma_lut_property
)
522 *val
= (state
->degamma_lut
) ? state
->degamma_lut
->base
.id
: 0;
523 else if (property
== config
->ctm_property
)
524 *val
= (state
->ctm
) ? state
->ctm
->base
.id
: 0;
525 else if (property
== config
->gamma_lut_property
)
526 *val
= (state
->gamma_lut
) ? state
->gamma_lut
->base
.id
: 0;
527 else if (crtc
->funcs
->atomic_get_property
)
528 return crtc
->funcs
->atomic_get_property(crtc
, state
, property
, val
);
536 * drm_atomic_crtc_check - check crtc state
537 * @crtc: crtc to check
538 * @state: crtc state to check
540 * Provides core sanity checks for crtc state.
543 * Zero on success, error code on failure
545 static int drm_atomic_crtc_check(struct drm_crtc
*crtc
,
546 struct drm_crtc_state
*state
)
548 /* NOTE: we explicitly don't enforce constraints such as primary
549 * layer covering entire screen, since that is something we want
550 * to allow (on hw that supports it). For hw that does not, it
551 * should be checked in driver's crtc->atomic_check() vfunc.
553 * TODO: Add generic modeset state checks once we support those.
556 if (state
->active
&& !state
->enable
) {
557 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active without enabled\n",
558 crtc
->base
.id
, crtc
->name
);
562 /* The state->enable vs. state->mode_blob checks can be WARN_ON,
563 * as this is a kernel-internal detail that userspace should never
564 * be able to trigger. */
565 if (drm_core_check_feature(crtc
->dev
, DRIVER_ATOMIC
) &&
566 WARN_ON(state
->enable
&& !state
->mode_blob
)) {
567 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled without mode blob\n",
568 crtc
->base
.id
, crtc
->name
);
572 if (drm_core_check_feature(crtc
->dev
, DRIVER_ATOMIC
) &&
573 WARN_ON(!state
->enable
&& state
->mode_blob
)) {
574 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled with mode blob\n",
575 crtc
->base
.id
, crtc
->name
);
580 * Reject event generation for when a CRTC is off and stays off.
581 * It wouldn't be hard to implement this, but userspace has a track
582 * record of happily burning through 100% cpu (or worse, crash) when the
583 * display pipe is suspended. To avoid all that fun just reject updates
584 * that ask for events since likely that indicates a bug in the
585 * compositor's drawing loop. This is consistent with the vblank IOCTL
586 * and legacy page_flip IOCTL which also reject service on a disabled
589 if (state
->event
&& !state
->active
&& !crtc
->state
->active
) {
590 DRM_DEBUG_ATOMIC("[CRTC:%d] requesting event but off\n",
599 * drm_atomic_get_plane_state - get plane state
600 * @state: global atomic state object
601 * @plane: plane to get state object for
603 * This function returns the plane state for the given plane, allocating it if
604 * needed. It will also grab the relevant plane lock to make sure that the state
609 * Either the allocated state or the error code encoded into the pointer. When
610 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
611 * entire atomic sequence must be restarted. All other errors are fatal.
613 struct drm_plane_state
*
614 drm_atomic_get_plane_state(struct drm_atomic_state
*state
,
615 struct drm_plane
*plane
)
617 int ret
, index
= drm_plane_index(plane
);
618 struct drm_plane_state
*plane_state
;
620 WARN_ON(!state
->acquire_ctx
);
622 plane_state
= drm_atomic_get_existing_plane_state(state
, plane
);
626 ret
= drm_modeset_lock(&plane
->mutex
, state
->acquire_ctx
);
630 plane_state
= plane
->funcs
->atomic_duplicate_state(plane
);
632 return ERR_PTR(-ENOMEM
);
634 state
->plane_states
[index
] = plane_state
;
635 state
->planes
[index
] = plane
;
636 plane_state
->state
= state
;
638 DRM_DEBUG_ATOMIC("Added [PLANE:%d:%s] %p state to %p\n",
639 plane
->base
.id
, plane
->name
, plane_state
, state
);
641 if (plane_state
->crtc
) {
642 struct drm_crtc_state
*crtc_state
;
644 crtc_state
= drm_atomic_get_crtc_state(state
,
646 if (IS_ERR(crtc_state
))
647 return ERR_CAST(crtc_state
);
652 EXPORT_SYMBOL(drm_atomic_get_plane_state
);
655 * drm_atomic_plane_set_property - set property on plane
656 * @plane: the drm plane to set a property on
657 * @state: the state object to update with the new property value
658 * @property: the property to set
659 * @val: the new property value
661 * Use this instead of calling plane->atomic_set_property directly.
662 * This function handles generic/core properties and calls out to
663 * driver's ->atomic_set_property() for driver properties. To ensure
664 * consistent behavior you must call this function rather than the
665 * driver hook directly.
668 * Zero on success, error code on failure
670 int drm_atomic_plane_set_property(struct drm_plane
*plane
,
671 struct drm_plane_state
*state
, struct drm_property
*property
,
674 struct drm_device
*dev
= plane
->dev
;
675 struct drm_mode_config
*config
= &dev
->mode_config
;
677 if (property
== config
->prop_fb_id
) {
678 struct drm_framebuffer
*fb
= drm_framebuffer_lookup(dev
, val
);
679 drm_atomic_set_fb_for_plane(state
, fb
);
681 drm_framebuffer_unreference(fb
);
682 } else if (property
== config
->prop_crtc_id
) {
683 struct drm_crtc
*crtc
= drm_crtc_find(dev
, val
);
684 return drm_atomic_set_crtc_for_plane(state
, crtc
);
685 } else if (property
== config
->prop_crtc_x
) {
686 state
->crtc_x
= U642I64(val
);
687 } else if (property
== config
->prop_crtc_y
) {
688 state
->crtc_y
= U642I64(val
);
689 } else if (property
== config
->prop_crtc_w
) {
691 } else if (property
== config
->prop_crtc_h
) {
693 } else if (property
== config
->prop_src_x
) {
695 } else if (property
== config
->prop_src_y
) {
697 } else if (property
== config
->prop_src_w
) {
699 } else if (property
== config
->prop_src_h
) {
701 } else if (property
== config
->rotation_property
) {
702 state
->rotation
= val
;
703 } else if (plane
->funcs
->atomic_set_property
) {
704 return plane
->funcs
->atomic_set_property(plane
, state
,
712 EXPORT_SYMBOL(drm_atomic_plane_set_property
);
715 * drm_atomic_plane_get_property - get property value from plane state
716 * @plane: the drm plane to set a property on
717 * @state: the state object to get the property value from
718 * @property: the property to set
719 * @val: return location for the property value
721 * This function handles generic/core properties and calls out to
722 * driver's ->atomic_get_property() for driver properties. To ensure
723 * consistent behavior you must call this function rather than the
724 * driver hook directly.
727 * Zero on success, error code on failure
730 drm_atomic_plane_get_property(struct drm_plane
*plane
,
731 const struct drm_plane_state
*state
,
732 struct drm_property
*property
, uint64_t *val
)
734 struct drm_device
*dev
= plane
->dev
;
735 struct drm_mode_config
*config
= &dev
->mode_config
;
737 if (property
== config
->prop_fb_id
) {
738 *val
= (state
->fb
) ? state
->fb
->base
.id
: 0;
739 } else if (property
== config
->prop_crtc_id
) {
740 *val
= (state
->crtc
) ? state
->crtc
->base
.id
: 0;
741 } else if (property
== config
->prop_crtc_x
) {
742 *val
= I642U64(state
->crtc_x
);
743 } else if (property
== config
->prop_crtc_y
) {
744 *val
= I642U64(state
->crtc_y
);
745 } else if (property
== config
->prop_crtc_w
) {
746 *val
= state
->crtc_w
;
747 } else if (property
== config
->prop_crtc_h
) {
748 *val
= state
->crtc_h
;
749 } else if (property
== config
->prop_src_x
) {
751 } else if (property
== config
->prop_src_y
) {
753 } else if (property
== config
->prop_src_w
) {
755 } else if (property
== config
->prop_src_h
) {
757 } else if (property
== config
->rotation_property
) {
758 *val
= state
->rotation
;
759 } else if (plane
->funcs
->atomic_get_property
) {
760 return plane
->funcs
->atomic_get_property(plane
, state
, property
, val
);
769 plane_switching_crtc(struct drm_atomic_state
*state
,
770 struct drm_plane
*plane
,
771 struct drm_plane_state
*plane_state
)
773 if (!plane
->state
->crtc
|| !plane_state
->crtc
)
776 if (plane
->state
->crtc
== plane_state
->crtc
)
779 /* This could be refined, but currently there's no helper or driver code
780 * to implement direct switching of active planes nor userspace to take
781 * advantage of more direct plane switching without the intermediate
788 * drm_atomic_plane_check - check plane state
789 * @plane: plane to check
790 * @state: plane state to check
792 * Provides core sanity checks for plane state.
795 * Zero on success, error code on failure
797 static int drm_atomic_plane_check(struct drm_plane
*plane
,
798 struct drm_plane_state
*state
)
800 unsigned int fb_width
, fb_height
;
803 /* either *both* CRTC and FB must be set, or neither */
804 if (WARN_ON(state
->crtc
&& !state
->fb
)) {
805 DRM_DEBUG_ATOMIC("CRTC set but no FB\n");
807 } else if (WARN_ON(state
->fb
&& !state
->crtc
)) {
808 DRM_DEBUG_ATOMIC("FB set but no CRTC\n");
812 /* if disabled, we don't care about the rest of the state: */
816 /* Check whether this plane is usable on this CRTC */
817 if (!(plane
->possible_crtcs
& drm_crtc_mask(state
->crtc
))) {
818 DRM_DEBUG_ATOMIC("Invalid crtc for plane\n");
822 /* Check whether this plane supports the fb pixel format. */
823 ret
= drm_plane_check_pixel_format(plane
, state
->fb
->pixel_format
);
825 DRM_DEBUG_ATOMIC("Invalid pixel format %s\n",
826 drm_get_format_name(state
->fb
->pixel_format
));
830 /* Give drivers some help against integer overflows */
831 if (state
->crtc_w
> INT_MAX
||
832 state
->crtc_x
> INT_MAX
- (int32_t) state
->crtc_w
||
833 state
->crtc_h
> INT_MAX
||
834 state
->crtc_y
> INT_MAX
- (int32_t) state
->crtc_h
) {
835 DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n",
836 state
->crtc_w
, state
->crtc_h
,
837 state
->crtc_x
, state
->crtc_y
);
841 fb_width
= state
->fb
->width
<< 16;
842 fb_height
= state
->fb
->height
<< 16;
844 /* Make sure source coordinates are inside the fb. */
845 if (state
->src_w
> fb_width
||
846 state
->src_x
> fb_width
- state
->src_w
||
847 state
->src_h
> fb_height
||
848 state
->src_y
> fb_height
- state
->src_h
) {
849 DRM_DEBUG_ATOMIC("Invalid source coordinates "
850 "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
851 state
->src_w
>> 16, ((state
->src_w
& 0xffff) * 15625) >> 10,
852 state
->src_h
>> 16, ((state
->src_h
& 0xffff) * 15625) >> 10,
853 state
->src_x
>> 16, ((state
->src_x
& 0xffff) * 15625) >> 10,
854 state
->src_y
>> 16, ((state
->src_y
& 0xffff) * 15625) >> 10);
858 if (plane_switching_crtc(state
->state
, plane
, state
)) {
859 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] switching CRTC directly\n",
860 plane
->base
.id
, plane
->name
);
868 * drm_atomic_get_connector_state - get connector state
869 * @state: global atomic state object
870 * @connector: connector to get state object for
872 * This function returns the connector state for the given connector,
873 * allocating it if needed. It will also grab the relevant connector lock to
874 * make sure that the state is consistent.
878 * Either the allocated state or the error code encoded into the pointer. When
879 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
880 * entire atomic sequence must be restarted. All other errors are fatal.
882 struct drm_connector_state
*
883 drm_atomic_get_connector_state(struct drm_atomic_state
*state
,
884 struct drm_connector
*connector
)
887 struct drm_mode_config
*config
= &connector
->dev
->mode_config
;
888 struct drm_connector_state
*connector_state
;
890 WARN_ON(!state
->acquire_ctx
);
892 ret
= drm_modeset_lock(&config
->connection_mutex
, state
->acquire_ctx
);
896 index
= drm_connector_index(connector
);
898 if (index
>= state
->num_connector
) {
899 struct drm_connector
**c
;
900 struct drm_connector_state
**cs
;
901 int alloc
= max(index
+ 1, config
->num_connector
);
903 c
= krealloc(state
->connectors
, alloc
* sizeof(*state
->connectors
), GFP_KERNEL
);
905 return ERR_PTR(-ENOMEM
);
907 state
->connectors
= c
;
908 memset(&state
->connectors
[state
->num_connector
], 0,
909 sizeof(*state
->connectors
) * (alloc
- state
->num_connector
));
911 cs
= krealloc(state
->connector_states
, alloc
* sizeof(*state
->connector_states
), GFP_KERNEL
);
913 return ERR_PTR(-ENOMEM
);
915 state
->connector_states
= cs
;
916 memset(&state
->connector_states
[state
->num_connector
], 0,
917 sizeof(*state
->connector_states
) * (alloc
- state
->num_connector
));
918 state
->num_connector
= alloc
;
921 if (state
->connector_states
[index
])
922 return state
->connector_states
[index
];
924 connector_state
= connector
->funcs
->atomic_duplicate_state(connector
);
925 if (!connector_state
)
926 return ERR_PTR(-ENOMEM
);
928 drm_connector_reference(connector
);
929 state
->connector_states
[index
] = connector_state
;
930 state
->connectors
[index
] = connector
;
931 connector_state
->state
= state
;
933 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d] %p state to %p\n",
934 connector
->base
.id
, connector_state
, state
);
936 if (connector_state
->crtc
) {
937 struct drm_crtc_state
*crtc_state
;
939 crtc_state
= drm_atomic_get_crtc_state(state
,
940 connector_state
->crtc
);
941 if (IS_ERR(crtc_state
))
942 return ERR_CAST(crtc_state
);
945 return connector_state
;
947 EXPORT_SYMBOL(drm_atomic_get_connector_state
);
950 * drm_atomic_connector_set_property - set property on connector.
951 * @connector: the drm connector to set a property on
952 * @state: the state object to update with the new property value
953 * @property: the property to set
954 * @val: the new property value
956 * Use this instead of calling connector->atomic_set_property directly.
957 * This function handles generic/core properties and calls out to
958 * driver's ->atomic_set_property() for driver properties. To ensure
959 * consistent behavior you must call this function rather than the
960 * driver hook directly.
963 * Zero on success, error code on failure
965 int drm_atomic_connector_set_property(struct drm_connector
*connector
,
966 struct drm_connector_state
*state
, struct drm_property
*property
,
969 struct drm_device
*dev
= connector
->dev
;
970 struct drm_mode_config
*config
= &dev
->mode_config
;
972 if (property
== config
->prop_crtc_id
) {
973 struct drm_crtc
*crtc
= drm_crtc_find(dev
, val
);
974 return drm_atomic_set_crtc_for_connector(state
, crtc
);
975 } else if (property
== config
->dpms_property
) {
976 /* setting DPMS property requires special handling, which
977 * is done in legacy setprop path for us. Disallow (for
978 * now?) atomic writes to DPMS property:
981 } else if (connector
->funcs
->atomic_set_property
) {
982 return connector
->funcs
->atomic_set_property(connector
,
983 state
, property
, val
);
988 EXPORT_SYMBOL(drm_atomic_connector_set_property
);
991 * drm_atomic_connector_get_property - get property value from connector state
992 * @connector: the drm connector to set a property on
993 * @state: the state object to get the property value from
994 * @property: the property to set
995 * @val: return location for the property value
997 * This function handles generic/core properties and calls out to
998 * driver's ->atomic_get_property() for driver properties. To ensure
999 * consistent behavior you must call this function rather than the
1000 * driver hook directly.
1003 * Zero on success, error code on failure
1006 drm_atomic_connector_get_property(struct drm_connector
*connector
,
1007 const struct drm_connector_state
*state
,
1008 struct drm_property
*property
, uint64_t *val
)
1010 struct drm_device
*dev
= connector
->dev
;
1011 struct drm_mode_config
*config
= &dev
->mode_config
;
1013 if (property
== config
->prop_crtc_id
) {
1014 *val
= (state
->crtc
) ? state
->crtc
->base
.id
: 0;
1015 } else if (property
== config
->dpms_property
) {
1016 *val
= connector
->dpms
;
1017 } else if (connector
->funcs
->atomic_get_property
) {
1018 return connector
->funcs
->atomic_get_property(connector
,
1019 state
, property
, val
);
1027 int drm_atomic_get_property(struct drm_mode_object
*obj
,
1028 struct drm_property
*property
, uint64_t *val
)
1030 struct drm_device
*dev
= property
->dev
;
1033 switch (obj
->type
) {
1034 case DRM_MODE_OBJECT_CONNECTOR
: {
1035 struct drm_connector
*connector
= obj_to_connector(obj
);
1036 WARN_ON(!drm_modeset_is_locked(&dev
->mode_config
.connection_mutex
));
1037 ret
= drm_atomic_connector_get_property(connector
,
1038 connector
->state
, property
, val
);
1041 case DRM_MODE_OBJECT_CRTC
: {
1042 struct drm_crtc
*crtc
= obj_to_crtc(obj
);
1043 WARN_ON(!drm_modeset_is_locked(&crtc
->mutex
));
1044 ret
= drm_atomic_crtc_get_property(crtc
,
1045 crtc
->state
, property
, val
);
1048 case DRM_MODE_OBJECT_PLANE
: {
1049 struct drm_plane
*plane
= obj_to_plane(obj
);
1050 WARN_ON(!drm_modeset_is_locked(&plane
->mutex
));
1051 ret
= drm_atomic_plane_get_property(plane
,
1052 plane
->state
, property
, val
);
1064 * drm_atomic_set_crtc_for_plane - set crtc for plane
1065 * @plane_state: the plane whose incoming state to update
1066 * @crtc: crtc to use for the plane
1068 * Changing the assigned crtc for a plane requires us to grab the lock and state
1069 * for the new crtc, as needed. This function takes care of all these details
1070 * besides updating the pointer in the state object itself.
1073 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1074 * then the w/w mutex code has detected a deadlock and the entire atomic
1075 * sequence must be restarted. All other errors are fatal.
1078 drm_atomic_set_crtc_for_plane(struct drm_plane_state
*plane_state
,
1079 struct drm_crtc
*crtc
)
1081 struct drm_plane
*plane
= plane_state
->plane
;
1082 struct drm_crtc_state
*crtc_state
;
1084 if (plane_state
->crtc
) {
1085 crtc_state
= drm_atomic_get_crtc_state(plane_state
->state
,
1087 if (WARN_ON(IS_ERR(crtc_state
)))
1088 return PTR_ERR(crtc_state
);
1090 crtc_state
->plane_mask
&= ~(1 << drm_plane_index(plane
));
1093 plane_state
->crtc
= crtc
;
1096 crtc_state
= drm_atomic_get_crtc_state(plane_state
->state
,
1098 if (IS_ERR(crtc_state
))
1099 return PTR_ERR(crtc_state
);
1100 crtc_state
->plane_mask
|= (1 << drm_plane_index(plane
));
1104 DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d:%s]\n",
1105 plane_state
, crtc
->base
.id
, crtc
->name
);
1107 DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n",
1112 EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane
);
1115 * drm_atomic_set_fb_for_plane - set framebuffer for plane
1116 * @plane_state: atomic state object for the plane
1117 * @fb: fb to use for the plane
1119 * Changing the assigned framebuffer for a plane requires us to grab a reference
1120 * to the new fb and drop the reference to the old fb, if there is one. This
1121 * function takes care of all these details besides updating the pointer in the
1122 * state object itself.
1125 drm_atomic_set_fb_for_plane(struct drm_plane_state
*plane_state
,
1126 struct drm_framebuffer
*fb
)
1128 if (plane_state
->fb
)
1129 drm_framebuffer_unreference(plane_state
->fb
);
1131 drm_framebuffer_reference(fb
);
1132 plane_state
->fb
= fb
;
1135 DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n",
1136 fb
->base
.id
, plane_state
);
1138 DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n",
1141 EXPORT_SYMBOL(drm_atomic_set_fb_for_plane
);
1144 * drm_atomic_set_crtc_for_connector - set crtc for connector
1145 * @conn_state: atomic state object for the connector
1146 * @crtc: crtc to use for the connector
1148 * Changing the assigned crtc for a connector requires us to grab the lock and
1149 * state for the new crtc, as needed. This function takes care of all these
1150 * details besides updating the pointer in the state object itself.
1153 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1154 * then the w/w mutex code has detected a deadlock and the entire atomic
1155 * sequence must be restarted. All other errors are fatal.
1158 drm_atomic_set_crtc_for_connector(struct drm_connector_state
*conn_state
,
1159 struct drm_crtc
*crtc
)
1161 struct drm_crtc_state
*crtc_state
;
1163 if (conn_state
->crtc
== crtc
)
1166 if (conn_state
->crtc
) {
1167 crtc_state
= drm_atomic_get_existing_crtc_state(conn_state
->state
,
1170 crtc_state
->connector_mask
&=
1171 ~(1 << drm_connector_index(conn_state
->connector
));
1173 drm_connector_unreference(conn_state
->connector
);
1174 conn_state
->crtc
= NULL
;
1178 crtc_state
= drm_atomic_get_crtc_state(conn_state
->state
, crtc
);
1179 if (IS_ERR(crtc_state
))
1180 return PTR_ERR(crtc_state
);
1182 crtc_state
->connector_mask
|=
1183 1 << drm_connector_index(conn_state
->connector
);
1185 drm_connector_reference(conn_state
->connector
);
1186 conn_state
->crtc
= crtc
;
1188 DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d:%s]\n",
1189 conn_state
, crtc
->base
.id
, crtc
->name
);
1191 DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n",
1197 EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector
);
1200 * drm_atomic_add_affected_connectors - add connectors for crtc
1201 * @state: atomic state
1204 * This function walks the current configuration and adds all connectors
1205 * currently using @crtc to the atomic configuration @state. Note that this
1206 * function must acquire the connection mutex. This can potentially cause
1207 * unneeded seralization if the update is just for the planes on one crtc. Hence
1208 * drivers and helpers should only call this when really needed (e.g. when a
1209 * full modeset needs to happen due to some change).
1212 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1213 * then the w/w mutex code has detected a deadlock and the entire atomic
1214 * sequence must be restarted. All other errors are fatal.
1217 drm_atomic_add_affected_connectors(struct drm_atomic_state
*state
,
1218 struct drm_crtc
*crtc
)
1220 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1221 struct drm_connector
*connector
;
1222 struct drm_connector_state
*conn_state
;
1225 ret
= drm_modeset_lock(&config
->connection_mutex
, state
->acquire_ctx
);
1229 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %p\n",
1230 crtc
->base
.id
, crtc
->name
, state
);
1233 * Changed connectors are already in @state, so only need to look at the
1234 * current configuration.
1236 drm_for_each_connector(connector
, state
->dev
) {
1237 if (connector
->state
->crtc
!= crtc
)
1240 conn_state
= drm_atomic_get_connector_state(state
, connector
);
1241 if (IS_ERR(conn_state
))
1242 return PTR_ERR(conn_state
);
1247 EXPORT_SYMBOL(drm_atomic_add_affected_connectors
);
1250 * drm_atomic_add_affected_planes - add planes for crtc
1251 * @state: atomic state
1254 * This function walks the current configuration and adds all planes
1255 * currently used by @crtc to the atomic configuration @state. This is useful
1256 * when an atomic commit also needs to check all currently enabled plane on
1257 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1258 * to avoid special code to force-enable all planes.
1260 * Since acquiring a plane state will always also acquire the w/w mutex of the
1261 * current CRTC for that plane (if there is any) adding all the plane states for
1262 * a CRTC will not reduce parallism of atomic updates.
1265 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1266 * then the w/w mutex code has detected a deadlock and the entire atomic
1267 * sequence must be restarted. All other errors are fatal.
1270 drm_atomic_add_affected_planes(struct drm_atomic_state
*state
,
1271 struct drm_crtc
*crtc
)
1273 struct drm_plane
*plane
;
1275 WARN_ON(!drm_atomic_get_existing_crtc_state(state
, crtc
));
1277 drm_for_each_plane_mask(plane
, state
->dev
, crtc
->state
->plane_mask
) {
1278 struct drm_plane_state
*plane_state
=
1279 drm_atomic_get_plane_state(state
, plane
);
1281 if (IS_ERR(plane_state
))
1282 return PTR_ERR(plane_state
);
1286 EXPORT_SYMBOL(drm_atomic_add_affected_planes
);
1289 * drm_atomic_legacy_backoff - locking backoff for legacy ioctls
1290 * @state: atomic state
1292 * This function should be used by legacy entry points which don't understand
1293 * -EDEADLK semantics. For simplicity this one will grab all modeset locks after
1294 * the slowpath completed.
1296 void drm_atomic_legacy_backoff(struct drm_atomic_state
*state
)
1301 drm_modeset_backoff(state
->acquire_ctx
);
1303 ret
= drm_modeset_lock_all_ctx(state
->dev
, state
->acquire_ctx
);
1307 EXPORT_SYMBOL(drm_atomic_legacy_backoff
);
1310 * drm_atomic_check_only - check whether a given config would work
1311 * @state: atomic configuration to check
1313 * Note that this function can return -EDEADLK if the driver needed to acquire
1314 * more locks but encountered a deadlock. The caller must then do the usual w/w
1315 * backoff dance and restart. All other errors are fatal.
1318 * 0 on success, negative error code on failure.
1320 int drm_atomic_check_only(struct drm_atomic_state
*state
)
1322 struct drm_device
*dev
= state
->dev
;
1323 struct drm_mode_config
*config
= &dev
->mode_config
;
1324 struct drm_plane
*plane
;
1325 struct drm_plane_state
*plane_state
;
1326 struct drm_crtc
*crtc
;
1327 struct drm_crtc_state
*crtc_state
;
1330 DRM_DEBUG_ATOMIC("checking %p\n", state
);
1332 for_each_plane_in_state(state
, plane
, plane_state
, i
) {
1333 ret
= drm_atomic_plane_check(plane
, plane_state
);
1335 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic core check failed\n",
1336 plane
->base
.id
, plane
->name
);
1341 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1342 ret
= drm_atomic_crtc_check(crtc
, crtc_state
);
1344 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic core check failed\n",
1345 crtc
->base
.id
, crtc
->name
);
1350 if (config
->funcs
->atomic_check
)
1351 ret
= config
->funcs
->atomic_check(state
->dev
, state
);
1353 if (!state
->allow_modeset
) {
1354 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1355 if (drm_atomic_crtc_needs_modeset(crtc_state
)) {
1356 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requires full modeset\n",
1357 crtc
->base
.id
, crtc
->name
);
1365 EXPORT_SYMBOL(drm_atomic_check_only
);
1368 * drm_atomic_commit - commit configuration atomically
1369 * @state: atomic configuration to check
1371 * Note that this function can return -EDEADLK if the driver needed to acquire
1372 * more locks but encountered a deadlock. The caller must then do the usual w/w
1373 * backoff dance and restart. All other errors are fatal.
1375 * Also note that on successful execution ownership of @state is transferred
1376 * from the caller of this function to the function itself. The caller must not
1377 * free or in any other way access @state. If the function fails then the caller
1378 * must clean up @state itself.
1381 * 0 on success, negative error code on failure.
1383 int drm_atomic_commit(struct drm_atomic_state
*state
)
1385 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1388 ret
= drm_atomic_check_only(state
);
1392 DRM_DEBUG_ATOMIC("commiting %p\n", state
);
1394 return config
->funcs
->atomic_commit(state
->dev
, state
, false);
1396 EXPORT_SYMBOL(drm_atomic_commit
);
1399 * drm_atomic_nonblocking_commit - atomic&nonblocking configuration commit
1400 * @state: atomic configuration to check
1402 * Note that this function can return -EDEADLK if the driver needed to acquire
1403 * more locks but encountered a deadlock. The caller must then do the usual w/w
1404 * backoff dance and restart. All other errors are fatal.
1406 * Also note that on successful execution ownership of @state is transferred
1407 * from the caller of this function to the function itself. The caller must not
1408 * free or in any other way access @state. If the function fails then the caller
1409 * must clean up @state itself.
1412 * 0 on success, negative error code on failure.
1414 int drm_atomic_nonblocking_commit(struct drm_atomic_state
*state
)
1416 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1419 ret
= drm_atomic_check_only(state
);
1423 DRM_DEBUG_ATOMIC("commiting %p nonblocking\n", state
);
1425 return config
->funcs
->atomic_commit(state
->dev
, state
, true);
1427 EXPORT_SYMBOL(drm_atomic_nonblocking_commit
);
1430 * The big monstor ioctl
1433 static struct drm_pending_vblank_event
*create_vblank_event(
1434 struct drm_device
*dev
, struct drm_file
*file_priv
, uint64_t user_data
)
1436 struct drm_pending_vblank_event
*e
= NULL
;
1439 e
= kzalloc(sizeof *e
, GFP_KERNEL
);
1443 e
->event
.base
.type
= DRM_EVENT_FLIP_COMPLETE
;
1444 e
->event
.base
.length
= sizeof(e
->event
);
1445 e
->event
.user_data
= user_data
;
1447 ret
= drm_event_reserve_init(dev
, file_priv
, &e
->base
, &e
->event
.base
);
1456 static int atomic_set_prop(struct drm_atomic_state
*state
,
1457 struct drm_mode_object
*obj
, struct drm_property
*prop
,
1458 uint64_t prop_value
)
1460 struct drm_mode_object
*ref
;
1463 if (!drm_property_change_valid_get(prop
, prop_value
, &ref
))
1466 switch (obj
->type
) {
1467 case DRM_MODE_OBJECT_CONNECTOR
: {
1468 struct drm_connector
*connector
= obj_to_connector(obj
);
1469 struct drm_connector_state
*connector_state
;
1471 connector_state
= drm_atomic_get_connector_state(state
, connector
);
1472 if (IS_ERR(connector_state
)) {
1473 ret
= PTR_ERR(connector_state
);
1477 ret
= drm_atomic_connector_set_property(connector
,
1478 connector_state
, prop
, prop_value
);
1481 case DRM_MODE_OBJECT_CRTC
: {
1482 struct drm_crtc
*crtc
= obj_to_crtc(obj
);
1483 struct drm_crtc_state
*crtc_state
;
1485 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
1486 if (IS_ERR(crtc_state
)) {
1487 ret
= PTR_ERR(crtc_state
);
1491 ret
= drm_atomic_crtc_set_property(crtc
,
1492 crtc_state
, prop
, prop_value
);
1495 case DRM_MODE_OBJECT_PLANE
: {
1496 struct drm_plane
*plane
= obj_to_plane(obj
);
1497 struct drm_plane_state
*plane_state
;
1499 plane_state
= drm_atomic_get_plane_state(state
, plane
);
1500 if (IS_ERR(plane_state
)) {
1501 ret
= PTR_ERR(plane_state
);
1505 ret
= drm_atomic_plane_set_property(plane
,
1506 plane_state
, prop
, prop_value
);
1514 drm_property_change_valid_put(prop
, ref
);
1519 * drm_atomic_clean_old_fb -- Unset old_fb pointers and set plane->fb pointers.
1521 * @dev: drm device to check.
1522 * @plane_mask: plane mask for planes that were updated.
1523 * @ret: return value, can be -EDEADLK for a retry.
1525 * Before doing an update plane->old_fb is set to plane->fb,
1526 * but before dropping the locks old_fb needs to be set to NULL
1527 * and plane->fb updated. This is a common operation for each
1528 * atomic update, so this call is split off as a helper.
1530 void drm_atomic_clean_old_fb(struct drm_device
*dev
,
1531 unsigned plane_mask
,
1534 struct drm_plane
*plane
;
1536 /* if succeeded, fixup legacy plane crtc/fb ptrs before dropping
1537 * locks (ie. while it is still safe to deref plane->state). We
1538 * need to do this here because the driver entry points cannot
1539 * distinguish between legacy and atomic ioctls.
1541 drm_for_each_plane_mask(plane
, dev
, plane_mask
) {
1543 struct drm_framebuffer
*new_fb
= plane
->state
->fb
;
1545 drm_framebuffer_reference(new_fb
);
1547 plane
->crtc
= plane
->state
->crtc
;
1550 drm_framebuffer_unreference(plane
->old_fb
);
1552 plane
->old_fb
= NULL
;
1555 EXPORT_SYMBOL(drm_atomic_clean_old_fb
);
1557 int drm_mode_atomic_ioctl(struct drm_device
*dev
,
1558 void *data
, struct drm_file
*file_priv
)
1560 struct drm_mode_atomic
*arg
= data
;
1561 uint32_t __user
*objs_ptr
= (uint32_t __user
*)(unsigned long)(arg
->objs_ptr
);
1562 uint32_t __user
*count_props_ptr
= (uint32_t __user
*)(unsigned long)(arg
->count_props_ptr
);
1563 uint32_t __user
*props_ptr
= (uint32_t __user
*)(unsigned long)(arg
->props_ptr
);
1564 uint64_t __user
*prop_values_ptr
= (uint64_t __user
*)(unsigned long)(arg
->prop_values_ptr
);
1565 unsigned int copied_objs
, copied_props
;
1566 struct drm_atomic_state
*state
;
1567 struct drm_modeset_acquire_ctx ctx
;
1568 struct drm_plane
*plane
;
1569 struct drm_crtc
*crtc
;
1570 struct drm_crtc_state
*crtc_state
;
1571 unsigned plane_mask
;
1575 /* disallow for drivers not supporting atomic: */
1576 if (!drm_core_check_feature(dev
, DRIVER_ATOMIC
))
1579 /* disallow for userspace that has not enabled atomic cap (even
1580 * though this may be a bit overkill, since legacy userspace
1581 * wouldn't know how to call this ioctl)
1583 if (!file_priv
->atomic
)
1586 if (arg
->flags
& ~DRM_MODE_ATOMIC_FLAGS
)
1592 if ((arg
->flags
& DRM_MODE_PAGE_FLIP_ASYNC
) &&
1593 !dev
->mode_config
.async_page_flip
)
1596 /* can't test and expect an event at the same time. */
1597 if ((arg
->flags
& DRM_MODE_ATOMIC_TEST_ONLY
) &&
1598 (arg
->flags
& DRM_MODE_PAGE_FLIP_EVENT
))
1601 drm_modeset_acquire_init(&ctx
, 0);
1603 state
= drm_atomic_state_alloc(dev
);
1607 state
->acquire_ctx
= &ctx
;
1608 state
->allow_modeset
= !!(arg
->flags
& DRM_MODE_ATOMIC_ALLOW_MODESET
);
1615 for (i
= 0; i
< arg
->count_objs
; i
++) {
1616 uint32_t obj_id
, count_props
;
1617 struct drm_mode_object
*obj
;
1619 if (get_user(obj_id
, objs_ptr
+ copied_objs
)) {
1624 obj
= drm_mode_object_find(dev
, obj_id
, DRM_MODE_OBJECT_ANY
);
1630 if (!obj
->properties
) {
1631 drm_mode_object_unreference(obj
);
1636 if (get_user(count_props
, count_props_ptr
+ copied_objs
)) {
1637 drm_mode_object_unreference(obj
);
1644 for (j
= 0; j
< count_props
; j
++) {
1646 uint64_t prop_value
;
1647 struct drm_property
*prop
;
1649 if (get_user(prop_id
, props_ptr
+ copied_props
)) {
1650 drm_mode_object_unreference(obj
);
1655 prop
= drm_property_find(dev
, prop_id
);
1657 drm_mode_object_unreference(obj
);
1662 if (copy_from_user(&prop_value
,
1663 prop_values_ptr
+ copied_props
,
1664 sizeof(prop_value
))) {
1665 drm_mode_object_unreference(obj
);
1670 ret
= atomic_set_prop(state
, obj
, prop
, prop_value
);
1672 drm_mode_object_unreference(obj
);
1679 if (obj
->type
== DRM_MODE_OBJECT_PLANE
&& count_props
&&
1680 !(arg
->flags
& DRM_MODE_ATOMIC_TEST_ONLY
)) {
1681 plane
= obj_to_plane(obj
);
1682 plane_mask
|= (1 << drm_plane_index(plane
));
1683 plane
->old_fb
= plane
->fb
;
1685 drm_mode_object_unreference(obj
);
1688 if (arg
->flags
& DRM_MODE_PAGE_FLIP_EVENT
) {
1689 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1690 struct drm_pending_vblank_event
*e
;
1692 e
= create_vblank_event(dev
, file_priv
, arg
->user_data
);
1698 crtc_state
->event
= e
;
1702 if (arg
->flags
& DRM_MODE_ATOMIC_TEST_ONLY
) {
1704 * Unlike commit, check_only does not clean up state.
1705 * Below we call drm_atomic_state_free for it.
1707 ret
= drm_atomic_check_only(state
);
1708 } else if (arg
->flags
& DRM_MODE_ATOMIC_NONBLOCK
) {
1709 ret
= drm_atomic_nonblocking_commit(state
);
1711 ret
= drm_atomic_commit(state
);
1715 drm_atomic_clean_old_fb(dev
, plane_mask
, ret
);
1717 if (ret
&& arg
->flags
& DRM_MODE_PAGE_FLIP_EVENT
) {
1719 * TEST_ONLY and PAGE_FLIP_EVENT are mutually exclusive,
1720 * if they weren't, this code should be called on success
1721 * for TEST_ONLY too.
1724 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1725 if (!crtc_state
->event
)
1728 drm_event_cancel_free(dev
, &crtc_state
->event
->base
);
1732 if (ret
== -EDEADLK
) {
1733 drm_atomic_state_clear(state
);
1734 drm_modeset_backoff(&ctx
);
1738 if (ret
|| arg
->flags
& DRM_MODE_ATOMIC_TEST_ONLY
)
1739 drm_atomic_state_free(state
);
1741 drm_modeset_drop_locks(&ctx
);
1742 drm_modeset_acquire_fini(&ctx
);