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"
36 static void crtc_commit_free(struct kref
*kref
)
38 struct drm_crtc_commit
*commit
=
39 container_of(kref
, struct drm_crtc_commit
, ref
);
44 void drm_crtc_commit_put(struct drm_crtc_commit
*commit
)
46 kref_put(&commit
->ref
, crtc_commit_free
);
48 EXPORT_SYMBOL(drm_crtc_commit_put
);
51 * drm_atomic_state_default_release -
52 * release memory initialized by drm_atomic_state_init
53 * @state: atomic state
55 * Free all the memory allocated by drm_atomic_state_init.
56 * This is useful for drivers that subclass the atomic state.
58 void drm_atomic_state_default_release(struct drm_atomic_state
*state
)
60 kfree(state
->connectors
);
64 EXPORT_SYMBOL(drm_atomic_state_default_release
);
67 * drm_atomic_state_init - init new atomic state
69 * @state: atomic state
71 * Default implementation for filling in a new atomic state.
72 * This is useful for drivers that subclass the atomic state.
75 drm_atomic_state_init(struct drm_device
*dev
, struct drm_atomic_state
*state
)
77 /* TODO legacy paths should maybe do a better job about
78 * setting this appropriately?
80 state
->allow_modeset
= true;
82 state
->crtcs
= kcalloc(dev
->mode_config
.num_crtc
,
83 sizeof(*state
->crtcs
), GFP_KERNEL
);
86 state
->planes
= kcalloc(dev
->mode_config
.num_total_plane
,
87 sizeof(*state
->planes
), GFP_KERNEL
);
93 DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state
);
97 drm_atomic_state_default_release(state
);
100 EXPORT_SYMBOL(drm_atomic_state_init
);
103 * drm_atomic_state_alloc - allocate atomic state
106 * This allocates an empty atomic state to track updates.
108 struct drm_atomic_state
*
109 drm_atomic_state_alloc(struct drm_device
*dev
)
111 struct drm_mode_config
*config
= &dev
->mode_config
;
112 struct drm_atomic_state
*state
;
114 if (!config
->funcs
->atomic_state_alloc
) {
115 state
= kzalloc(sizeof(*state
), GFP_KERNEL
);
118 if (drm_atomic_state_init(dev
, state
) < 0) {
125 return config
->funcs
->atomic_state_alloc(dev
);
127 EXPORT_SYMBOL(drm_atomic_state_alloc
);
130 * drm_atomic_state_default_clear - clear base atomic state
131 * @state: atomic state
133 * Default implementation for clearing atomic state.
134 * This is useful for drivers that subclass the atomic state.
136 void drm_atomic_state_default_clear(struct drm_atomic_state
*state
)
138 struct drm_device
*dev
= state
->dev
;
139 struct drm_mode_config
*config
= &dev
->mode_config
;
142 DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state
);
144 for (i
= 0; i
< state
->num_connector
; i
++) {
145 struct drm_connector
*connector
= state
->connectors
[i
].ptr
;
150 connector
->funcs
->atomic_destroy_state(connector
,
151 state
->connectors
[i
].state
);
152 state
->connectors
[i
].ptr
= NULL
;
153 state
->connectors
[i
].state
= NULL
;
154 drm_connector_unreference(connector
);
157 for (i
= 0; i
< config
->num_crtc
; i
++) {
158 struct drm_crtc
*crtc
= state
->crtcs
[i
].ptr
;
163 crtc
->funcs
->atomic_destroy_state(crtc
,
164 state
->crtcs
[i
].state
);
166 if (state
->crtcs
[i
].commit
) {
167 kfree(state
->crtcs
[i
].commit
->event
);
168 state
->crtcs
[i
].commit
->event
= NULL
;
169 drm_crtc_commit_put(state
->crtcs
[i
].commit
);
172 state
->crtcs
[i
].commit
= NULL
;
173 state
->crtcs
[i
].ptr
= NULL
;
174 state
->crtcs
[i
].state
= NULL
;
177 for (i
= 0; i
< config
->num_total_plane
; i
++) {
178 struct drm_plane
*plane
= state
->planes
[i
].ptr
;
183 plane
->funcs
->atomic_destroy_state(plane
,
184 state
->planes
[i
].state
);
185 state
->planes
[i
].ptr
= NULL
;
186 state
->planes
[i
].state
= NULL
;
189 EXPORT_SYMBOL(drm_atomic_state_default_clear
);
192 * drm_atomic_state_clear - clear state object
193 * @state: atomic state
195 * When the w/w mutex algorithm detects a deadlock we need to back off and drop
196 * all locks. So someone else could sneak in and change the current modeset
197 * configuration. Which means that all the state assembled in @state is no
198 * longer an atomic update to the current state, but to some arbitrary earlier
199 * state. Which could break assumptions the driver's ->atomic_check likely
202 * Hence we must clear all cached state and completely start over, using this
205 void drm_atomic_state_clear(struct drm_atomic_state
*state
)
207 struct drm_device
*dev
= state
->dev
;
208 struct drm_mode_config
*config
= &dev
->mode_config
;
210 if (config
->funcs
->atomic_state_clear
)
211 config
->funcs
->atomic_state_clear(state
);
213 drm_atomic_state_default_clear(state
);
215 EXPORT_SYMBOL(drm_atomic_state_clear
);
218 * drm_atomic_state_free - free all memory for an atomic state
219 * @state: atomic state to deallocate
221 * This frees all memory associated with an atomic state, including all the
222 * per-object state for planes, crtcs and connectors.
224 void drm_atomic_state_free(struct drm_atomic_state
*state
)
226 struct drm_device
*dev
;
227 struct drm_mode_config
*config
;
233 config
= &dev
->mode_config
;
235 drm_atomic_state_clear(state
);
237 DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state
);
239 if (config
->funcs
->atomic_state_free
) {
240 config
->funcs
->atomic_state_free(state
);
242 drm_atomic_state_default_release(state
);
246 EXPORT_SYMBOL(drm_atomic_state_free
);
249 * drm_atomic_get_crtc_state - get crtc state
250 * @state: global atomic state object
251 * @crtc: crtc to get state object for
253 * This function returns the crtc state for the given crtc, allocating it if
254 * needed. It will also grab the relevant crtc lock to make sure that the state
259 * Either the allocated state or the error code encoded into the pointer. When
260 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
261 * entire atomic sequence must be restarted. All other errors are fatal.
263 struct drm_crtc_state
*
264 drm_atomic_get_crtc_state(struct drm_atomic_state
*state
,
265 struct drm_crtc
*crtc
)
267 int ret
, index
= drm_crtc_index(crtc
);
268 struct drm_crtc_state
*crtc_state
;
270 WARN_ON(!state
->acquire_ctx
);
272 crtc_state
= drm_atomic_get_existing_crtc_state(state
, crtc
);
276 ret
= drm_modeset_lock(&crtc
->mutex
, state
->acquire_ctx
);
280 crtc_state
= crtc
->funcs
->atomic_duplicate_state(crtc
);
282 return ERR_PTR(-ENOMEM
);
284 state
->crtcs
[index
].state
= crtc_state
;
285 state
->crtcs
[index
].ptr
= crtc
;
286 crtc_state
->state
= state
;
288 DRM_DEBUG_ATOMIC("Added [CRTC:%d:%s] %p state to %p\n",
289 crtc
->base
.id
, crtc
->name
, crtc_state
, state
);
293 EXPORT_SYMBOL(drm_atomic_get_crtc_state
);
296 * drm_atomic_set_mode_for_crtc - set mode for CRTC
297 * @state: the CRTC whose incoming state to update
298 * @mode: kernel-internal mode to use for the CRTC, or NULL to disable
300 * Set a mode (originating from the kernel) on the desired CRTC state. Does
301 * not change any other state properties, including enable, active, or
305 * Zero on success, error code on failure. Cannot return -EDEADLK.
307 int drm_atomic_set_mode_for_crtc(struct drm_crtc_state
*state
,
308 struct drm_display_mode
*mode
)
310 struct drm_mode_modeinfo umode
;
312 /* Early return for no change. */
313 if (mode
&& memcmp(&state
->mode
, mode
, sizeof(*mode
)) == 0)
316 drm_property_unreference_blob(state
->mode_blob
);
317 state
->mode_blob
= NULL
;
320 drm_mode_convert_to_umode(&umode
, mode
);
322 drm_property_create_blob(state
->crtc
->dev
,
325 if (IS_ERR(state
->mode_blob
))
326 return PTR_ERR(state
->mode_blob
);
328 drm_mode_copy(&state
->mode
, mode
);
329 state
->enable
= true;
330 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
333 memset(&state
->mode
, 0, sizeof(state
->mode
));
334 state
->enable
= false;
335 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
341 EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc
);
344 * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC
345 * @state: the CRTC whose incoming state to update
346 * @blob: pointer to blob property to use for mode
348 * Set a mode (originating from a blob property) on the desired CRTC state.
349 * This function will take a reference on the blob property for the CRTC state,
350 * and release the reference held on the state's existing mode property, if any
354 * Zero on success, error code on failure. Cannot return -EDEADLK.
356 int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state
*state
,
357 struct drm_property_blob
*blob
)
359 if (blob
== state
->mode_blob
)
362 drm_property_unreference_blob(state
->mode_blob
);
363 state
->mode_blob
= NULL
;
365 memset(&state
->mode
, 0, sizeof(state
->mode
));
368 if (blob
->length
!= sizeof(struct drm_mode_modeinfo
) ||
369 drm_mode_convert_umode(&state
->mode
,
370 (const struct drm_mode_modeinfo
*)
374 state
->mode_blob
= drm_property_reference_blob(blob
);
375 state
->enable
= true;
376 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
377 state
->mode
.name
, state
);
379 state
->enable
= false;
380 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
386 EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc
);
389 * drm_atomic_replace_property_blob - replace a blob property
390 * @blob: a pointer to the member blob to be replaced
391 * @new_blob: the new blob to replace with
392 * @replaced: whether the blob has been replaced
395 * Zero on success, error code on failure
398 drm_atomic_replace_property_blob(struct drm_property_blob
**blob
,
399 struct drm_property_blob
*new_blob
,
402 struct drm_property_blob
*old_blob
= *blob
;
404 if (old_blob
== new_blob
)
407 drm_property_unreference_blob(old_blob
);
409 drm_property_reference_blob(new_blob
);
417 drm_atomic_replace_property_blob_from_id(struct drm_crtc
*crtc
,
418 struct drm_property_blob
**blob
,
420 ssize_t expected_size
,
423 struct drm_device
*dev
= crtc
->dev
;
424 struct drm_property_blob
*new_blob
= NULL
;
427 new_blob
= drm_property_lookup_blob(dev
, blob_id
);
428 if (new_blob
== NULL
)
430 if (expected_size
> 0 && expected_size
!= new_blob
->length
)
434 drm_atomic_replace_property_blob(blob
, new_blob
, replaced
);
440 * drm_atomic_crtc_set_property - set property on CRTC
441 * @crtc: the drm CRTC to set a property on
442 * @state: the state object to update with the new property value
443 * @property: the property to set
444 * @val: the new property value
446 * Use this instead of calling crtc->atomic_set_property directly.
447 * This function handles generic/core properties and calls out to
448 * driver's ->atomic_set_property() for driver properties. To ensure
449 * consistent behavior you must call this function rather than the
450 * driver hook directly.
453 * Zero on success, error code on failure
455 int drm_atomic_crtc_set_property(struct drm_crtc
*crtc
,
456 struct drm_crtc_state
*state
, struct drm_property
*property
,
459 struct drm_device
*dev
= crtc
->dev
;
460 struct drm_mode_config
*config
= &dev
->mode_config
;
461 bool replaced
= false;
464 if (property
== config
->prop_active
)
466 else if (property
== config
->prop_mode_id
) {
467 struct drm_property_blob
*mode
=
468 drm_property_lookup_blob(dev
, val
);
469 ret
= drm_atomic_set_mode_prop_for_crtc(state
, mode
);
470 drm_property_unreference_blob(mode
);
472 } else if (property
== config
->degamma_lut_property
) {
473 ret
= drm_atomic_replace_property_blob_from_id(crtc
,
478 state
->color_mgmt_changed
|= replaced
;
480 } else if (property
== config
->ctm_property
) {
481 ret
= drm_atomic_replace_property_blob_from_id(crtc
,
484 sizeof(struct drm_color_ctm
),
486 state
->color_mgmt_changed
|= replaced
;
488 } else if (property
== config
->gamma_lut_property
) {
489 ret
= drm_atomic_replace_property_blob_from_id(crtc
,
494 state
->color_mgmt_changed
|= replaced
;
496 } else if (crtc
->funcs
->atomic_set_property
)
497 return crtc
->funcs
->atomic_set_property(crtc
, state
, property
, val
);
503 EXPORT_SYMBOL(drm_atomic_crtc_set_property
);
506 * drm_atomic_crtc_get_property - get property value from CRTC state
507 * @crtc: the drm CRTC to set a property on
508 * @state: the state object to get the property value from
509 * @property: the property to set
510 * @val: return location for the property value
512 * This function handles generic/core properties and calls out to
513 * driver's ->atomic_get_property() for driver properties. To ensure
514 * consistent behavior you must call this function rather than the
515 * driver hook directly.
518 * Zero on success, error code on failure
521 drm_atomic_crtc_get_property(struct drm_crtc
*crtc
,
522 const struct drm_crtc_state
*state
,
523 struct drm_property
*property
, uint64_t *val
)
525 struct drm_device
*dev
= crtc
->dev
;
526 struct drm_mode_config
*config
= &dev
->mode_config
;
528 if (property
== config
->prop_active
)
529 *val
= state
->active
;
530 else if (property
== config
->prop_mode_id
)
531 *val
= (state
->mode_blob
) ? state
->mode_blob
->base
.id
: 0;
532 else if (property
== config
->degamma_lut_property
)
533 *val
= (state
->degamma_lut
) ? state
->degamma_lut
->base
.id
: 0;
534 else if (property
== config
->ctm_property
)
535 *val
= (state
->ctm
) ? state
->ctm
->base
.id
: 0;
536 else if (property
== config
->gamma_lut_property
)
537 *val
= (state
->gamma_lut
) ? state
->gamma_lut
->base
.id
: 0;
538 else if (crtc
->funcs
->atomic_get_property
)
539 return crtc
->funcs
->atomic_get_property(crtc
, state
, property
, val
);
547 * drm_atomic_crtc_check - check crtc state
548 * @crtc: crtc to check
549 * @state: crtc state to check
551 * Provides core sanity checks for crtc state.
554 * Zero on success, error code on failure
556 static int drm_atomic_crtc_check(struct drm_crtc
*crtc
,
557 struct drm_crtc_state
*state
)
559 /* NOTE: we explicitly don't enforce constraints such as primary
560 * layer covering entire screen, since that is something we want
561 * to allow (on hw that supports it). For hw that does not, it
562 * should be checked in driver's crtc->atomic_check() vfunc.
564 * TODO: Add generic modeset state checks once we support those.
567 if (state
->active
&& !state
->enable
) {
568 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active without enabled\n",
569 crtc
->base
.id
, crtc
->name
);
573 /* The state->enable vs. state->mode_blob checks can be WARN_ON,
574 * as this is a kernel-internal detail that userspace should never
575 * be able to trigger. */
576 if (drm_core_check_feature(crtc
->dev
, DRIVER_ATOMIC
) &&
577 WARN_ON(state
->enable
&& !state
->mode_blob
)) {
578 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled without mode blob\n",
579 crtc
->base
.id
, crtc
->name
);
583 if (drm_core_check_feature(crtc
->dev
, DRIVER_ATOMIC
) &&
584 WARN_ON(!state
->enable
&& state
->mode_blob
)) {
585 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled with mode blob\n",
586 crtc
->base
.id
, crtc
->name
);
591 * Reject event generation for when a CRTC is off and stays off.
592 * It wouldn't be hard to implement this, but userspace has a track
593 * record of happily burning through 100% cpu (or worse, crash) when the
594 * display pipe is suspended. To avoid all that fun just reject updates
595 * that ask for events since likely that indicates a bug in the
596 * compositor's drawing loop. This is consistent with the vblank IOCTL
597 * and legacy page_flip IOCTL which also reject service on a disabled
600 if (state
->event
&& !state
->active
&& !crtc
->state
->active
) {
601 DRM_DEBUG_ATOMIC("[CRTC:%d] requesting event but off\n",
610 * drm_atomic_get_plane_state - get plane state
611 * @state: global atomic state object
612 * @plane: plane to get state object for
614 * This function returns the plane state for the given plane, allocating it if
615 * needed. It will also grab the relevant plane lock to make sure that the state
620 * Either the allocated state or the error code encoded into the pointer. When
621 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
622 * entire atomic sequence must be restarted. All other errors are fatal.
624 struct drm_plane_state
*
625 drm_atomic_get_plane_state(struct drm_atomic_state
*state
,
626 struct drm_plane
*plane
)
628 int ret
, index
= drm_plane_index(plane
);
629 struct drm_plane_state
*plane_state
;
631 WARN_ON(!state
->acquire_ctx
);
633 plane_state
= drm_atomic_get_existing_plane_state(state
, plane
);
637 ret
= drm_modeset_lock(&plane
->mutex
, state
->acquire_ctx
);
641 plane_state
= plane
->funcs
->atomic_duplicate_state(plane
);
643 return ERR_PTR(-ENOMEM
);
645 state
->planes
[index
].state
= plane_state
;
646 state
->planes
[index
].ptr
= plane
;
647 plane_state
->state
= state
;
649 DRM_DEBUG_ATOMIC("Added [PLANE:%d:%s] %p state to %p\n",
650 plane
->base
.id
, plane
->name
, plane_state
, state
);
652 if (plane_state
->crtc
) {
653 struct drm_crtc_state
*crtc_state
;
655 crtc_state
= drm_atomic_get_crtc_state(state
,
657 if (IS_ERR(crtc_state
))
658 return ERR_CAST(crtc_state
);
663 EXPORT_SYMBOL(drm_atomic_get_plane_state
);
666 * drm_atomic_plane_set_property - set property on plane
667 * @plane: the drm plane to set a property on
668 * @state: the state object to update with the new property value
669 * @property: the property to set
670 * @val: the new property value
672 * Use this instead of calling plane->atomic_set_property directly.
673 * This function handles generic/core properties and calls out to
674 * driver's ->atomic_set_property() for driver properties. To ensure
675 * consistent behavior you must call this function rather than the
676 * driver hook directly.
679 * Zero on success, error code on failure
681 int drm_atomic_plane_set_property(struct drm_plane
*plane
,
682 struct drm_plane_state
*state
, struct drm_property
*property
,
685 struct drm_device
*dev
= plane
->dev
;
686 struct drm_mode_config
*config
= &dev
->mode_config
;
688 if (property
== config
->prop_fb_id
) {
689 struct drm_framebuffer
*fb
= drm_framebuffer_lookup(dev
, val
);
690 drm_atomic_set_fb_for_plane(state
, fb
);
692 drm_framebuffer_unreference(fb
);
693 } else if (property
== config
->prop_crtc_id
) {
694 struct drm_crtc
*crtc
= drm_crtc_find(dev
, val
);
695 return drm_atomic_set_crtc_for_plane(state
, crtc
);
696 } else if (property
== config
->prop_crtc_x
) {
697 state
->crtc_x
= U642I64(val
);
698 } else if (property
== config
->prop_crtc_y
) {
699 state
->crtc_y
= U642I64(val
);
700 } else if (property
== config
->prop_crtc_w
) {
702 } else if (property
== config
->prop_crtc_h
) {
704 } else if (property
== config
->prop_src_x
) {
706 } else if (property
== config
->prop_src_y
) {
708 } else if (property
== config
->prop_src_w
) {
710 } else if (property
== config
->prop_src_h
) {
712 } else if (property
== config
->rotation_property
) {
713 state
->rotation
= val
;
714 } else if (property
== plane
->zpos_property
) {
716 } else if (plane
->funcs
->atomic_set_property
) {
717 return plane
->funcs
->atomic_set_property(plane
, state
,
725 EXPORT_SYMBOL(drm_atomic_plane_set_property
);
728 * drm_atomic_plane_get_property - get property value from plane state
729 * @plane: the drm plane to set a property on
730 * @state: the state object to get the property value from
731 * @property: the property to set
732 * @val: return location for the property value
734 * This function handles generic/core properties and calls out to
735 * driver's ->atomic_get_property() for driver properties. To ensure
736 * consistent behavior you must call this function rather than the
737 * driver hook directly.
740 * Zero on success, error code on failure
743 drm_atomic_plane_get_property(struct drm_plane
*plane
,
744 const struct drm_plane_state
*state
,
745 struct drm_property
*property
, uint64_t *val
)
747 struct drm_device
*dev
= plane
->dev
;
748 struct drm_mode_config
*config
= &dev
->mode_config
;
750 if (property
== config
->prop_fb_id
) {
751 *val
= (state
->fb
) ? state
->fb
->base
.id
: 0;
752 } else if (property
== config
->prop_crtc_id
) {
753 *val
= (state
->crtc
) ? state
->crtc
->base
.id
: 0;
754 } else if (property
== config
->prop_crtc_x
) {
755 *val
= I642U64(state
->crtc_x
);
756 } else if (property
== config
->prop_crtc_y
) {
757 *val
= I642U64(state
->crtc_y
);
758 } else if (property
== config
->prop_crtc_w
) {
759 *val
= state
->crtc_w
;
760 } else if (property
== config
->prop_crtc_h
) {
761 *val
= state
->crtc_h
;
762 } else if (property
== config
->prop_src_x
) {
764 } else if (property
== config
->prop_src_y
) {
766 } else if (property
== config
->prop_src_w
) {
768 } else if (property
== config
->prop_src_h
) {
770 } else if (property
== config
->rotation_property
) {
771 *val
= state
->rotation
;
772 } else if (property
== plane
->zpos_property
) {
774 } else if (plane
->funcs
->atomic_get_property
) {
775 return plane
->funcs
->atomic_get_property(plane
, state
, property
, val
);
784 plane_switching_crtc(struct drm_atomic_state
*state
,
785 struct drm_plane
*plane
,
786 struct drm_plane_state
*plane_state
)
788 if (!plane
->state
->crtc
|| !plane_state
->crtc
)
791 if (plane
->state
->crtc
== plane_state
->crtc
)
794 /* This could be refined, but currently there's no helper or driver code
795 * to implement direct switching of active planes nor userspace to take
796 * advantage of more direct plane switching without the intermediate
803 * drm_atomic_plane_check - check plane state
804 * @plane: plane to check
805 * @state: plane state to check
807 * Provides core sanity checks for plane state.
810 * Zero on success, error code on failure
812 static int drm_atomic_plane_check(struct drm_plane
*plane
,
813 struct drm_plane_state
*state
)
815 unsigned int fb_width
, fb_height
;
818 /* either *both* CRTC and FB must be set, or neither */
819 if (WARN_ON(state
->crtc
&& !state
->fb
)) {
820 DRM_DEBUG_ATOMIC("CRTC set but no FB\n");
822 } else if (WARN_ON(state
->fb
&& !state
->crtc
)) {
823 DRM_DEBUG_ATOMIC("FB set but no CRTC\n");
827 /* if disabled, we don't care about the rest of the state: */
831 /* Check whether this plane is usable on this CRTC */
832 if (!(plane
->possible_crtcs
& drm_crtc_mask(state
->crtc
))) {
833 DRM_DEBUG_ATOMIC("Invalid crtc for plane\n");
837 /* Check whether this plane supports the fb pixel format. */
838 ret
= drm_plane_check_pixel_format(plane
, state
->fb
->pixel_format
);
840 char *format_name
= drm_get_format_name(state
->fb
->pixel_format
);
841 DRM_DEBUG_ATOMIC("Invalid pixel format %s\n", format_name
);
846 /* Give drivers some help against integer overflows */
847 if (state
->crtc_w
> INT_MAX
||
848 state
->crtc_x
> INT_MAX
- (int32_t) state
->crtc_w
||
849 state
->crtc_h
> INT_MAX
||
850 state
->crtc_y
> INT_MAX
- (int32_t) state
->crtc_h
) {
851 DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n",
852 state
->crtc_w
, state
->crtc_h
,
853 state
->crtc_x
, state
->crtc_y
);
857 fb_width
= state
->fb
->width
<< 16;
858 fb_height
= state
->fb
->height
<< 16;
860 /* Make sure source coordinates are inside the fb. */
861 if (state
->src_w
> fb_width
||
862 state
->src_x
> fb_width
- state
->src_w
||
863 state
->src_h
> fb_height
||
864 state
->src_y
> fb_height
- state
->src_h
) {
865 DRM_DEBUG_ATOMIC("Invalid source coordinates "
866 "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
867 state
->src_w
>> 16, ((state
->src_w
& 0xffff) * 15625) >> 10,
868 state
->src_h
>> 16, ((state
->src_h
& 0xffff) * 15625) >> 10,
869 state
->src_x
>> 16, ((state
->src_x
& 0xffff) * 15625) >> 10,
870 state
->src_y
>> 16, ((state
->src_y
& 0xffff) * 15625) >> 10);
874 if (plane_switching_crtc(state
->state
, plane
, state
)) {
875 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] switching CRTC directly\n",
876 plane
->base
.id
, plane
->name
);
884 * drm_atomic_get_connector_state - get connector state
885 * @state: global atomic state object
886 * @connector: connector to get state object for
888 * This function returns the connector state for the given connector,
889 * allocating it if needed. It will also grab the relevant connector lock to
890 * make sure that the state is consistent.
894 * Either the allocated state or the error code encoded into the pointer. When
895 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
896 * entire atomic sequence must be restarted. All other errors are fatal.
898 struct drm_connector_state
*
899 drm_atomic_get_connector_state(struct drm_atomic_state
*state
,
900 struct drm_connector
*connector
)
903 struct drm_mode_config
*config
= &connector
->dev
->mode_config
;
904 struct drm_connector_state
*connector_state
;
906 WARN_ON(!state
->acquire_ctx
);
908 ret
= drm_modeset_lock(&config
->connection_mutex
, state
->acquire_ctx
);
912 index
= drm_connector_index(connector
);
914 if (index
>= state
->num_connector
) {
915 struct __drm_connnectors_state
*c
;
916 int alloc
= max(index
+ 1, config
->num_connector
);
918 c
= krealloc(state
->connectors
, alloc
* sizeof(*state
->connectors
), GFP_KERNEL
);
920 return ERR_PTR(-ENOMEM
);
922 state
->connectors
= c
;
923 memset(&state
->connectors
[state
->num_connector
], 0,
924 sizeof(*state
->connectors
) * (alloc
- state
->num_connector
));
926 state
->num_connector
= alloc
;
929 if (state
->connectors
[index
].state
)
930 return state
->connectors
[index
].state
;
932 connector_state
= connector
->funcs
->atomic_duplicate_state(connector
);
933 if (!connector_state
)
934 return ERR_PTR(-ENOMEM
);
936 drm_connector_reference(connector
);
937 state
->connectors
[index
].state
= connector_state
;
938 state
->connectors
[index
].ptr
= connector
;
939 connector_state
->state
= state
;
941 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d] %p state to %p\n",
942 connector
->base
.id
, connector_state
, state
);
944 if (connector_state
->crtc
) {
945 struct drm_crtc_state
*crtc_state
;
947 crtc_state
= drm_atomic_get_crtc_state(state
,
948 connector_state
->crtc
);
949 if (IS_ERR(crtc_state
))
950 return ERR_CAST(crtc_state
);
953 return connector_state
;
955 EXPORT_SYMBOL(drm_atomic_get_connector_state
);
958 * drm_atomic_connector_set_property - set property on connector.
959 * @connector: the drm connector to set a property on
960 * @state: the state object to update with the new property value
961 * @property: the property to set
962 * @val: the new property value
964 * Use this instead of calling connector->atomic_set_property directly.
965 * This function handles generic/core properties and calls out to
966 * driver's ->atomic_set_property() for driver properties. To ensure
967 * consistent behavior you must call this function rather than the
968 * driver hook directly.
971 * Zero on success, error code on failure
973 int drm_atomic_connector_set_property(struct drm_connector
*connector
,
974 struct drm_connector_state
*state
, struct drm_property
*property
,
977 struct drm_device
*dev
= connector
->dev
;
978 struct drm_mode_config
*config
= &dev
->mode_config
;
980 if (property
== config
->prop_crtc_id
) {
981 struct drm_crtc
*crtc
= drm_crtc_find(dev
, val
);
982 return drm_atomic_set_crtc_for_connector(state
, crtc
);
983 } else if (property
== config
->dpms_property
) {
984 /* setting DPMS property requires special handling, which
985 * is done in legacy setprop path for us. Disallow (for
986 * now?) atomic writes to DPMS property:
989 } else if (connector
->funcs
->atomic_set_property
) {
990 return connector
->funcs
->atomic_set_property(connector
,
991 state
, property
, val
);
996 EXPORT_SYMBOL(drm_atomic_connector_set_property
);
999 * drm_atomic_connector_get_property - get property value from connector state
1000 * @connector: the drm connector to set a property on
1001 * @state: the state object to get the property value from
1002 * @property: the property to set
1003 * @val: return location for the property value
1005 * This function handles generic/core properties and calls out to
1006 * driver's ->atomic_get_property() for driver properties. To ensure
1007 * consistent behavior you must call this function rather than the
1008 * driver hook directly.
1011 * Zero on success, error code on failure
1014 drm_atomic_connector_get_property(struct drm_connector
*connector
,
1015 const struct drm_connector_state
*state
,
1016 struct drm_property
*property
, uint64_t *val
)
1018 struct drm_device
*dev
= connector
->dev
;
1019 struct drm_mode_config
*config
= &dev
->mode_config
;
1021 if (property
== config
->prop_crtc_id
) {
1022 *val
= (state
->crtc
) ? state
->crtc
->base
.id
: 0;
1023 } else if (property
== config
->dpms_property
) {
1024 *val
= connector
->dpms
;
1025 } else if (connector
->funcs
->atomic_get_property
) {
1026 return connector
->funcs
->atomic_get_property(connector
,
1027 state
, property
, val
);
1035 int drm_atomic_get_property(struct drm_mode_object
*obj
,
1036 struct drm_property
*property
, uint64_t *val
)
1038 struct drm_device
*dev
= property
->dev
;
1041 switch (obj
->type
) {
1042 case DRM_MODE_OBJECT_CONNECTOR
: {
1043 struct drm_connector
*connector
= obj_to_connector(obj
);
1044 WARN_ON(!drm_modeset_is_locked(&dev
->mode_config
.connection_mutex
));
1045 ret
= drm_atomic_connector_get_property(connector
,
1046 connector
->state
, property
, val
);
1049 case DRM_MODE_OBJECT_CRTC
: {
1050 struct drm_crtc
*crtc
= obj_to_crtc(obj
);
1051 WARN_ON(!drm_modeset_is_locked(&crtc
->mutex
));
1052 ret
= drm_atomic_crtc_get_property(crtc
,
1053 crtc
->state
, property
, val
);
1056 case DRM_MODE_OBJECT_PLANE
: {
1057 struct drm_plane
*plane
= obj_to_plane(obj
);
1058 WARN_ON(!drm_modeset_is_locked(&plane
->mutex
));
1059 ret
= drm_atomic_plane_get_property(plane
,
1060 plane
->state
, property
, val
);
1072 * drm_atomic_set_crtc_for_plane - set crtc for plane
1073 * @plane_state: the plane whose incoming state to update
1074 * @crtc: crtc to use for the plane
1076 * Changing the assigned crtc for a plane requires us to grab the lock and state
1077 * for the new crtc, as needed. This function takes care of all these details
1078 * besides updating the pointer in the state object itself.
1081 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1082 * then the w/w mutex code has detected a deadlock and the entire atomic
1083 * sequence must be restarted. All other errors are fatal.
1086 drm_atomic_set_crtc_for_plane(struct drm_plane_state
*plane_state
,
1087 struct drm_crtc
*crtc
)
1089 struct drm_plane
*plane
= plane_state
->plane
;
1090 struct drm_crtc_state
*crtc_state
;
1092 if (plane_state
->crtc
) {
1093 crtc_state
= drm_atomic_get_crtc_state(plane_state
->state
,
1095 if (WARN_ON(IS_ERR(crtc_state
)))
1096 return PTR_ERR(crtc_state
);
1098 crtc_state
->plane_mask
&= ~(1 << drm_plane_index(plane
));
1101 plane_state
->crtc
= crtc
;
1104 crtc_state
= drm_atomic_get_crtc_state(plane_state
->state
,
1106 if (IS_ERR(crtc_state
))
1107 return PTR_ERR(crtc_state
);
1108 crtc_state
->plane_mask
|= (1 << drm_plane_index(plane
));
1112 DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d:%s]\n",
1113 plane_state
, crtc
->base
.id
, crtc
->name
);
1115 DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n",
1120 EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane
);
1123 * drm_atomic_set_fb_for_plane - set framebuffer for plane
1124 * @plane_state: atomic state object for the plane
1125 * @fb: fb to use for the plane
1127 * Changing the assigned framebuffer for a plane requires us to grab a reference
1128 * to the new fb and drop the reference to the old fb, if there is one. This
1129 * function takes care of all these details besides updating the pointer in the
1130 * state object itself.
1133 drm_atomic_set_fb_for_plane(struct drm_plane_state
*plane_state
,
1134 struct drm_framebuffer
*fb
)
1136 if (plane_state
->fb
)
1137 drm_framebuffer_unreference(plane_state
->fb
);
1139 drm_framebuffer_reference(fb
);
1140 plane_state
->fb
= fb
;
1143 DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n",
1144 fb
->base
.id
, plane_state
);
1146 DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n",
1149 EXPORT_SYMBOL(drm_atomic_set_fb_for_plane
);
1152 * drm_atomic_set_crtc_for_connector - set crtc for connector
1153 * @conn_state: atomic state object for the connector
1154 * @crtc: crtc to use for the connector
1156 * Changing the assigned crtc for a connector requires us to grab the lock and
1157 * state for the new crtc, as needed. This function takes care of all these
1158 * details besides updating the pointer in the state object itself.
1161 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1162 * then the w/w mutex code has detected a deadlock and the entire atomic
1163 * sequence must be restarted. All other errors are fatal.
1166 drm_atomic_set_crtc_for_connector(struct drm_connector_state
*conn_state
,
1167 struct drm_crtc
*crtc
)
1169 struct drm_crtc_state
*crtc_state
;
1171 if (conn_state
->crtc
== crtc
)
1174 if (conn_state
->crtc
) {
1175 crtc_state
= drm_atomic_get_existing_crtc_state(conn_state
->state
,
1178 crtc_state
->connector_mask
&=
1179 ~(1 << drm_connector_index(conn_state
->connector
));
1181 drm_connector_unreference(conn_state
->connector
);
1182 conn_state
->crtc
= NULL
;
1186 crtc_state
= drm_atomic_get_crtc_state(conn_state
->state
, crtc
);
1187 if (IS_ERR(crtc_state
))
1188 return PTR_ERR(crtc_state
);
1190 crtc_state
->connector_mask
|=
1191 1 << drm_connector_index(conn_state
->connector
);
1193 drm_connector_reference(conn_state
->connector
);
1194 conn_state
->crtc
= crtc
;
1196 DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d:%s]\n",
1197 conn_state
, crtc
->base
.id
, crtc
->name
);
1199 DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n",
1205 EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector
);
1208 * drm_atomic_add_affected_connectors - add connectors for crtc
1209 * @state: atomic state
1212 * This function walks the current configuration and adds all connectors
1213 * currently using @crtc to the atomic configuration @state. Note that this
1214 * function must acquire the connection mutex. This can potentially cause
1215 * unneeded seralization if the update is just for the planes on one crtc. Hence
1216 * drivers and helpers should only call this when really needed (e.g. when a
1217 * full modeset needs to happen due to some change).
1220 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1221 * then the w/w mutex code has detected a deadlock and the entire atomic
1222 * sequence must be restarted. All other errors are fatal.
1225 drm_atomic_add_affected_connectors(struct drm_atomic_state
*state
,
1226 struct drm_crtc
*crtc
)
1228 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1229 struct drm_connector
*connector
;
1230 struct drm_connector_state
*conn_state
;
1233 ret
= drm_modeset_lock(&config
->connection_mutex
, state
->acquire_ctx
);
1237 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %p\n",
1238 crtc
->base
.id
, crtc
->name
, state
);
1241 * Changed connectors are already in @state, so only need to look at the
1242 * current configuration.
1244 drm_for_each_connector(connector
, state
->dev
) {
1245 if (connector
->state
->crtc
!= crtc
)
1248 conn_state
= drm_atomic_get_connector_state(state
, connector
);
1249 if (IS_ERR(conn_state
))
1250 return PTR_ERR(conn_state
);
1255 EXPORT_SYMBOL(drm_atomic_add_affected_connectors
);
1258 * drm_atomic_add_affected_planes - add planes for crtc
1259 * @state: atomic state
1262 * This function walks the current configuration and adds all planes
1263 * currently used by @crtc to the atomic configuration @state. This is useful
1264 * when an atomic commit also needs to check all currently enabled plane on
1265 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1266 * to avoid special code to force-enable all planes.
1268 * Since acquiring a plane state will always also acquire the w/w mutex of the
1269 * current CRTC for that plane (if there is any) adding all the plane states for
1270 * a CRTC will not reduce parallism of atomic updates.
1273 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1274 * then the w/w mutex code has detected a deadlock and the entire atomic
1275 * sequence must be restarted. All other errors are fatal.
1278 drm_atomic_add_affected_planes(struct drm_atomic_state
*state
,
1279 struct drm_crtc
*crtc
)
1281 struct drm_plane
*plane
;
1283 WARN_ON(!drm_atomic_get_existing_crtc_state(state
, crtc
));
1285 drm_for_each_plane_mask(plane
, state
->dev
, crtc
->state
->plane_mask
) {
1286 struct drm_plane_state
*plane_state
=
1287 drm_atomic_get_plane_state(state
, plane
);
1289 if (IS_ERR(plane_state
))
1290 return PTR_ERR(plane_state
);
1294 EXPORT_SYMBOL(drm_atomic_add_affected_planes
);
1297 * drm_atomic_legacy_backoff - locking backoff for legacy ioctls
1298 * @state: atomic state
1300 * This function should be used by legacy entry points which don't understand
1301 * -EDEADLK semantics. For simplicity this one will grab all modeset locks after
1302 * the slowpath completed.
1304 void drm_atomic_legacy_backoff(struct drm_atomic_state
*state
)
1306 struct drm_device
*dev
= state
->dev
;
1307 unsigned crtc_mask
= 0;
1308 struct drm_crtc
*crtc
;
1310 bool global
= false;
1312 drm_for_each_crtc(crtc
, dev
) {
1313 if (crtc
->acquire_ctx
!= state
->acquire_ctx
)
1316 crtc_mask
|= drm_crtc_mask(crtc
);
1317 crtc
->acquire_ctx
= NULL
;
1320 if (WARN_ON(dev
->mode_config
.acquire_ctx
== state
->acquire_ctx
)) {
1323 dev
->mode_config
.acquire_ctx
= NULL
;
1327 drm_modeset_backoff(state
->acquire_ctx
);
1329 ret
= drm_modeset_lock_all_ctx(dev
, state
->acquire_ctx
);
1333 drm_for_each_crtc(crtc
, dev
)
1334 if (drm_crtc_mask(crtc
) & crtc_mask
)
1335 crtc
->acquire_ctx
= state
->acquire_ctx
;
1338 dev
->mode_config
.acquire_ctx
= state
->acquire_ctx
;
1340 EXPORT_SYMBOL(drm_atomic_legacy_backoff
);
1343 * drm_atomic_check_only - check whether a given config would work
1344 * @state: atomic configuration to check
1346 * Note that this function can return -EDEADLK if the driver needed to acquire
1347 * more locks but encountered a deadlock. The caller must then do the usual w/w
1348 * backoff dance and restart. All other errors are fatal.
1351 * 0 on success, negative error code on failure.
1353 int drm_atomic_check_only(struct drm_atomic_state
*state
)
1355 struct drm_device
*dev
= state
->dev
;
1356 struct drm_mode_config
*config
= &dev
->mode_config
;
1357 struct drm_plane
*plane
;
1358 struct drm_plane_state
*plane_state
;
1359 struct drm_crtc
*crtc
;
1360 struct drm_crtc_state
*crtc_state
;
1363 DRM_DEBUG_ATOMIC("checking %p\n", state
);
1365 for_each_plane_in_state(state
, plane
, plane_state
, i
) {
1366 ret
= drm_atomic_plane_check(plane
, plane_state
);
1368 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic core check failed\n",
1369 plane
->base
.id
, plane
->name
);
1374 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1375 ret
= drm_atomic_crtc_check(crtc
, crtc_state
);
1377 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic core check failed\n",
1378 crtc
->base
.id
, crtc
->name
);
1383 if (config
->funcs
->atomic_check
)
1384 ret
= config
->funcs
->atomic_check(state
->dev
, state
);
1386 if (!state
->allow_modeset
) {
1387 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1388 if (drm_atomic_crtc_needs_modeset(crtc_state
)) {
1389 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requires full modeset\n",
1390 crtc
->base
.id
, crtc
->name
);
1398 EXPORT_SYMBOL(drm_atomic_check_only
);
1401 * drm_atomic_commit - commit configuration atomically
1402 * @state: atomic configuration to check
1404 * Note that this function can return -EDEADLK if the driver needed to acquire
1405 * more locks but encountered a deadlock. The caller must then do the usual w/w
1406 * backoff dance and restart. All other errors are fatal.
1408 * Also note that on successful execution ownership of @state is transferred
1409 * from the caller of this function to the function itself. The caller must not
1410 * free or in any other way access @state. If the function fails then the caller
1411 * must clean up @state itself.
1414 * 0 on success, negative error code on failure.
1416 int drm_atomic_commit(struct drm_atomic_state
*state
)
1418 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1421 ret
= drm_atomic_check_only(state
);
1425 DRM_DEBUG_ATOMIC("commiting %p\n", state
);
1427 return config
->funcs
->atomic_commit(state
->dev
, state
, false);
1429 EXPORT_SYMBOL(drm_atomic_commit
);
1432 * drm_atomic_nonblocking_commit - atomic&nonblocking configuration commit
1433 * @state: atomic configuration to check
1435 * Note that this function can return -EDEADLK if the driver needed to acquire
1436 * more locks but encountered a deadlock. The caller must then do the usual w/w
1437 * backoff dance and restart. All other errors are fatal.
1439 * Also note that on successful execution ownership of @state is transferred
1440 * from the caller of this function to the function itself. The caller must not
1441 * free or in any other way access @state. If the function fails then the caller
1442 * must clean up @state itself.
1445 * 0 on success, negative error code on failure.
1447 int drm_atomic_nonblocking_commit(struct drm_atomic_state
*state
)
1449 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1452 ret
= drm_atomic_check_only(state
);
1456 DRM_DEBUG_ATOMIC("commiting %p nonblocking\n", state
);
1458 return config
->funcs
->atomic_commit(state
->dev
, state
, true);
1460 EXPORT_SYMBOL(drm_atomic_nonblocking_commit
);
1463 * The big monstor ioctl
1466 static struct drm_pending_vblank_event
*create_vblank_event(
1467 struct drm_device
*dev
, struct drm_file
*file_priv
,
1468 struct fence
*fence
, uint64_t user_data
)
1470 struct drm_pending_vblank_event
*e
= NULL
;
1473 e
= kzalloc(sizeof *e
, GFP_KERNEL
);
1477 e
->event
.base
.type
= DRM_EVENT_FLIP_COMPLETE
;
1478 e
->event
.base
.length
= sizeof(e
->event
);
1479 e
->event
.user_data
= user_data
;
1482 ret
= drm_event_reserve_init(dev
, file_priv
, &e
->base
,
1490 e
->base
.fence
= fence
;
1495 static int atomic_set_prop(struct drm_atomic_state
*state
,
1496 struct drm_mode_object
*obj
, struct drm_property
*prop
,
1497 uint64_t prop_value
)
1499 struct drm_mode_object
*ref
;
1502 if (!drm_property_change_valid_get(prop
, prop_value
, &ref
))
1505 switch (obj
->type
) {
1506 case DRM_MODE_OBJECT_CONNECTOR
: {
1507 struct drm_connector
*connector
= obj_to_connector(obj
);
1508 struct drm_connector_state
*connector_state
;
1510 connector_state
= drm_atomic_get_connector_state(state
, connector
);
1511 if (IS_ERR(connector_state
)) {
1512 ret
= PTR_ERR(connector_state
);
1516 ret
= drm_atomic_connector_set_property(connector
,
1517 connector_state
, prop
, prop_value
);
1520 case DRM_MODE_OBJECT_CRTC
: {
1521 struct drm_crtc
*crtc
= obj_to_crtc(obj
);
1522 struct drm_crtc_state
*crtc_state
;
1524 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
1525 if (IS_ERR(crtc_state
)) {
1526 ret
= PTR_ERR(crtc_state
);
1530 ret
= drm_atomic_crtc_set_property(crtc
,
1531 crtc_state
, prop
, prop_value
);
1534 case DRM_MODE_OBJECT_PLANE
: {
1535 struct drm_plane
*plane
= obj_to_plane(obj
);
1536 struct drm_plane_state
*plane_state
;
1538 plane_state
= drm_atomic_get_plane_state(state
, plane
);
1539 if (IS_ERR(plane_state
)) {
1540 ret
= PTR_ERR(plane_state
);
1544 ret
= drm_atomic_plane_set_property(plane
,
1545 plane_state
, prop
, prop_value
);
1553 drm_property_change_valid_put(prop
, ref
);
1558 * drm_atomic_clean_old_fb -- Unset old_fb pointers and set plane->fb pointers.
1560 * @dev: drm device to check.
1561 * @plane_mask: plane mask for planes that were updated.
1562 * @ret: return value, can be -EDEADLK for a retry.
1564 * Before doing an update plane->old_fb is set to plane->fb,
1565 * but before dropping the locks old_fb needs to be set to NULL
1566 * and plane->fb updated. This is a common operation for each
1567 * atomic update, so this call is split off as a helper.
1569 void drm_atomic_clean_old_fb(struct drm_device
*dev
,
1570 unsigned plane_mask
,
1573 struct drm_plane
*plane
;
1575 /* if succeeded, fixup legacy plane crtc/fb ptrs before dropping
1576 * locks (ie. while it is still safe to deref plane->state). We
1577 * need to do this here because the driver entry points cannot
1578 * distinguish between legacy and atomic ioctls.
1580 drm_for_each_plane_mask(plane
, dev
, plane_mask
) {
1582 struct drm_framebuffer
*new_fb
= plane
->state
->fb
;
1584 drm_framebuffer_reference(new_fb
);
1586 plane
->crtc
= plane
->state
->crtc
;
1589 drm_framebuffer_unreference(plane
->old_fb
);
1591 plane
->old_fb
= NULL
;
1594 EXPORT_SYMBOL(drm_atomic_clean_old_fb
);
1596 int drm_mode_atomic_ioctl(struct drm_device
*dev
,
1597 void *data
, struct drm_file
*file_priv
)
1599 struct drm_mode_atomic
*arg
= data
;
1600 uint32_t __user
*objs_ptr
= (uint32_t __user
*)(unsigned long)(arg
->objs_ptr
);
1601 uint32_t __user
*count_props_ptr
= (uint32_t __user
*)(unsigned long)(arg
->count_props_ptr
);
1602 uint32_t __user
*props_ptr
= (uint32_t __user
*)(unsigned long)(arg
->props_ptr
);
1603 uint64_t __user
*prop_values_ptr
= (uint64_t __user
*)(unsigned long)(arg
->prop_values_ptr
);
1604 unsigned int copied_objs
, copied_props
;
1605 struct drm_atomic_state
*state
;
1606 struct drm_modeset_acquire_ctx ctx
;
1607 struct drm_plane
*plane
;
1608 struct drm_crtc
*crtc
;
1609 struct drm_crtc_state
*crtc_state
;
1610 unsigned plane_mask
;
1612 unsigned int i
, j
, k
;
1614 /* disallow for drivers not supporting atomic: */
1615 if (!drm_core_check_feature(dev
, DRIVER_ATOMIC
))
1618 /* disallow for userspace that has not enabled atomic cap (even
1619 * though this may be a bit overkill, since legacy userspace
1620 * wouldn't know how to call this ioctl)
1622 if (!file_priv
->atomic
)
1625 if (arg
->flags
& ~DRM_MODE_ATOMIC_FLAGS
)
1631 if ((arg
->flags
& DRM_MODE_PAGE_FLIP_ASYNC
) &&
1632 !dev
->mode_config
.async_page_flip
)
1635 /* can't test and expect an event at the same time. */
1636 if ((arg
->flags
& DRM_MODE_ATOMIC_TEST_ONLY
) &&
1637 (arg
->flags
& DRM_MODE_PAGE_FLIP_EVENT
))
1640 drm_modeset_acquire_init(&ctx
, 0);
1642 state
= drm_atomic_state_alloc(dev
);
1646 state
->acquire_ctx
= &ctx
;
1647 state
->allow_modeset
= !!(arg
->flags
& DRM_MODE_ATOMIC_ALLOW_MODESET
);
1654 for (i
= 0; i
< arg
->count_objs
; i
++) {
1655 uint32_t obj_id
, count_props
;
1656 struct drm_mode_object
*obj
;
1658 if (get_user(obj_id
, objs_ptr
+ copied_objs
)) {
1663 obj
= drm_mode_object_find(dev
, obj_id
, DRM_MODE_OBJECT_ANY
);
1669 if (!obj
->properties
) {
1670 drm_mode_object_unreference(obj
);
1675 if (get_user(count_props
, count_props_ptr
+ copied_objs
)) {
1676 drm_mode_object_unreference(obj
);
1683 for (j
= 0; j
< count_props
; j
++) {
1685 uint64_t prop_value
;
1686 struct drm_property
*prop
;
1688 if (get_user(prop_id
, props_ptr
+ copied_props
)) {
1689 drm_mode_object_unreference(obj
);
1694 for (k
= 0; k
< obj
->properties
->count
; k
++)
1695 if (obj
->properties
->properties
[k
]->base
.id
== prop_id
)
1698 if (k
== obj
->properties
->count
) {
1703 prop
= drm_property_find(dev
, prop_id
);
1705 drm_mode_object_unreference(obj
);
1710 if (copy_from_user(&prop_value
,
1711 prop_values_ptr
+ copied_props
,
1712 sizeof(prop_value
))) {
1713 drm_mode_object_unreference(obj
);
1718 ret
= atomic_set_prop(state
, obj
, prop
, prop_value
);
1720 drm_mode_object_unreference(obj
);
1727 if (obj
->type
== DRM_MODE_OBJECT_PLANE
&& count_props
&&
1728 !(arg
->flags
& DRM_MODE_ATOMIC_TEST_ONLY
)) {
1729 plane
= obj_to_plane(obj
);
1730 plane_mask
|= (1 << drm_plane_index(plane
));
1731 plane
->old_fb
= plane
->fb
;
1733 drm_mode_object_unreference(obj
);
1736 if (arg
->flags
& DRM_MODE_PAGE_FLIP_EVENT
) {
1737 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1738 struct drm_pending_vblank_event
*e
;
1740 e
= create_vblank_event(dev
, file_priv
, NULL
,
1747 crtc_state
->event
= e
;
1751 if (arg
->flags
& DRM_MODE_ATOMIC_TEST_ONLY
) {
1753 * Unlike commit, check_only does not clean up state.
1754 * Below we call drm_atomic_state_free for it.
1756 ret
= drm_atomic_check_only(state
);
1757 } else if (arg
->flags
& DRM_MODE_ATOMIC_NONBLOCK
) {
1758 ret
= drm_atomic_nonblocking_commit(state
);
1760 ret
= drm_atomic_commit(state
);
1764 drm_atomic_clean_old_fb(dev
, plane_mask
, ret
);
1766 if (ret
&& arg
->flags
& DRM_MODE_PAGE_FLIP_EVENT
) {
1768 * TEST_ONLY and PAGE_FLIP_EVENT are mutually exclusive,
1769 * if they weren't, this code should be called on success
1770 * for TEST_ONLY too.
1773 for_each_crtc_in_state(state
, crtc
, crtc_state
, i
) {
1774 if (!crtc_state
->event
)
1777 drm_event_cancel_free(dev
, &crtc_state
->event
->base
);
1781 if (ret
== -EDEADLK
) {
1782 drm_atomic_state_clear(state
);
1783 drm_modeset_backoff(&ctx
);
1787 if (ret
|| arg
->flags
& DRM_MODE_ATOMIC_TEST_ONLY
)
1788 drm_atomic_state_free(state
);
1790 drm_modeset_drop_locks(&ctx
);
1791 drm_modeset_acquire_fini(&ctx
);