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>
33 #include <drm/drm_print.h>
34 #include <linux/sync_file.h>
36 #include "drm_crtc_internal.h"
38 static void crtc_commit_free(struct kref *kref)
40 struct drm_crtc_commit *commit =
41 container_of(kref, struct drm_crtc_commit, ref);
46 void drm_crtc_commit_put(struct drm_crtc_commit *commit)
48 kref_put(&commit->ref, crtc_commit_free);
50 EXPORT_SYMBOL(drm_crtc_commit_put);
53 * drm_atomic_state_default_release -
54 * release memory initialized by drm_atomic_state_init
55 * @state: atomic state
57 * Free all the memory allocated by drm_atomic_state_init.
58 * This is useful for drivers that subclass the atomic state.
60 void drm_atomic_state_default_release(struct drm_atomic_state *state)
62 kfree(state->connectors);
66 EXPORT_SYMBOL(drm_atomic_state_default_release);
69 * drm_atomic_state_init - init new atomic state
71 * @state: atomic state
73 * Default implementation for filling in a new atomic state.
74 * This is useful for drivers that subclass the atomic state.
77 drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state)
79 kref_init(&state->ref);
81 /* TODO legacy paths should maybe do a better job about
82 * setting this appropriately?
84 state->allow_modeset = true;
86 state->crtcs = kcalloc(dev->mode_config.num_crtc,
87 sizeof(*state->crtcs), GFP_KERNEL);
90 state->planes = kcalloc(dev->mode_config.num_total_plane,
91 sizeof(*state->planes), GFP_KERNEL);
97 DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state);
101 drm_atomic_state_default_release(state);
104 EXPORT_SYMBOL(drm_atomic_state_init);
107 * drm_atomic_state_alloc - allocate atomic state
110 * This allocates an empty atomic state to track updates.
112 struct drm_atomic_state *
113 drm_atomic_state_alloc(struct drm_device *dev)
115 struct drm_mode_config *config = &dev->mode_config;
116 struct drm_atomic_state *state;
118 if (!config->funcs->atomic_state_alloc) {
119 state = kzalloc(sizeof(*state), GFP_KERNEL);
122 if (drm_atomic_state_init(dev, state) < 0) {
129 return config->funcs->atomic_state_alloc(dev);
131 EXPORT_SYMBOL(drm_atomic_state_alloc);
134 * drm_atomic_state_default_clear - clear base atomic state
135 * @state: atomic state
137 * Default implementation for clearing atomic state.
138 * This is useful for drivers that subclass the atomic state.
140 void drm_atomic_state_default_clear(struct drm_atomic_state *state)
142 struct drm_device *dev = state->dev;
143 struct drm_mode_config *config = &dev->mode_config;
146 DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state);
148 for (i = 0; i < state->num_connector; i++) {
149 struct drm_connector *connector = state->connectors[i].ptr;
154 connector->funcs->atomic_destroy_state(connector,
155 state->connectors[i].state);
156 state->connectors[i].ptr = NULL;
157 state->connectors[i].state = NULL;
158 drm_connector_unreference(connector);
161 for (i = 0; i < config->num_crtc; i++) {
162 struct drm_crtc *crtc = state->crtcs[i].ptr;
167 crtc->funcs->atomic_destroy_state(crtc,
168 state->crtcs[i].state);
170 if (state->crtcs[i].commit) {
171 kfree(state->crtcs[i].commit->event);
172 state->crtcs[i].commit->event = NULL;
173 drm_crtc_commit_put(state->crtcs[i].commit);
176 state->crtcs[i].commit = NULL;
177 state->crtcs[i].ptr = NULL;
178 state->crtcs[i].state = NULL;
181 for (i = 0; i < config->num_total_plane; i++) {
182 struct drm_plane *plane = state->planes[i].ptr;
187 plane->funcs->atomic_destroy_state(plane,
188 state->planes[i].state);
189 state->planes[i].ptr = NULL;
190 state->planes[i].state = NULL;
193 EXPORT_SYMBOL(drm_atomic_state_default_clear);
196 * drm_atomic_state_clear - clear state object
197 * @state: atomic state
199 * When the w/w mutex algorithm detects a deadlock we need to back off and drop
200 * all locks. So someone else could sneak in and change the current modeset
201 * configuration. Which means that all the state assembled in @state is no
202 * longer an atomic update to the current state, but to some arbitrary earlier
203 * state. Which could break assumptions the driver's ->atomic_check likely
206 * Hence we must clear all cached state and completely start over, using this
209 void drm_atomic_state_clear(struct drm_atomic_state *state)
211 struct drm_device *dev = state->dev;
212 struct drm_mode_config *config = &dev->mode_config;
214 if (config->funcs->atomic_state_clear)
215 config->funcs->atomic_state_clear(state);
217 drm_atomic_state_default_clear(state);
219 EXPORT_SYMBOL(drm_atomic_state_clear);
222 * __drm_atomic_state_free - free all memory for an atomic state
223 * @ref: This atomic state to deallocate
225 * This frees all memory associated with an atomic state, including all the
226 * per-object state for planes, crtcs and connectors.
228 void __drm_atomic_state_free(struct kref *ref)
230 struct drm_atomic_state *state = container_of(ref, typeof(*state), ref);
231 struct drm_mode_config *config = &state->dev->mode_config;
233 drm_atomic_state_clear(state);
235 DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state);
237 if (config->funcs->atomic_state_free) {
238 config->funcs->atomic_state_free(state);
240 drm_atomic_state_default_release(state);
244 EXPORT_SYMBOL(__drm_atomic_state_free);
247 * drm_atomic_get_crtc_state - get crtc state
248 * @state: global atomic state object
249 * @crtc: crtc to get state object for
251 * This function returns the crtc state for the given crtc, allocating it if
252 * needed. It will also grab the relevant crtc lock to make sure that the state
257 * Either the allocated state or the error code encoded into the pointer. When
258 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
259 * entire atomic sequence must be restarted. All other errors are fatal.
261 struct drm_crtc_state *
262 drm_atomic_get_crtc_state(struct drm_atomic_state *state,
263 struct drm_crtc *crtc)
265 int ret, index = drm_crtc_index(crtc);
266 struct drm_crtc_state *crtc_state;
268 WARN_ON(!state->acquire_ctx);
270 crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
274 ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
278 crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
280 return ERR_PTR(-ENOMEM);
282 state->crtcs[index].state = crtc_state;
283 state->crtcs[index].ptr = crtc;
284 crtc_state->state = state;
286 DRM_DEBUG_ATOMIC("Added [CRTC:%d:%s] %p state to %p\n",
287 crtc->base.id, crtc->name, crtc_state, state);
291 EXPORT_SYMBOL(drm_atomic_get_crtc_state);
293 static void set_out_fence_for_crtc(struct drm_atomic_state *state,
294 struct drm_crtc *crtc, s64 __user *fence_ptr)
296 state->crtcs[drm_crtc_index(crtc)].out_fence_ptr = fence_ptr;
299 static s64 __user *get_out_fence_for_crtc(struct drm_atomic_state *state,
300 struct drm_crtc *crtc)
302 s64 __user *fence_ptr;
304 fence_ptr = state->crtcs[drm_crtc_index(crtc)].out_fence_ptr;
305 state->crtcs[drm_crtc_index(crtc)].out_fence_ptr = NULL;
311 * drm_atomic_set_mode_for_crtc - set mode for CRTC
312 * @state: the CRTC whose incoming state to update
313 * @mode: kernel-internal mode to use for the CRTC, or NULL to disable
315 * Set a mode (originating from the kernel) on the desired CRTC state. Does
316 * not change any other state properties, including enable, active, or
320 * Zero on success, error code on failure. Cannot return -EDEADLK.
322 int drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,
323 struct drm_display_mode *mode)
325 struct drm_mode_modeinfo umode;
327 /* Early return for no change. */
328 if (mode && memcmp(&state->mode, mode, sizeof(*mode)) == 0)
331 drm_property_unreference_blob(state->mode_blob);
332 state->mode_blob = NULL;
335 drm_mode_convert_to_umode(&umode, mode);
337 drm_property_create_blob(state->crtc->dev,
340 if (IS_ERR(state->mode_blob))
341 return PTR_ERR(state->mode_blob);
343 drm_mode_copy(&state->mode, mode);
344 state->enable = true;
345 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
348 memset(&state->mode, 0, sizeof(state->mode));
349 state->enable = false;
350 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
356 EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc);
359 * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC
360 * @state: the CRTC whose incoming state to update
361 * @blob: pointer to blob property to use for mode
363 * Set a mode (originating from a blob property) on the desired CRTC state.
364 * This function will take a reference on the blob property for the CRTC state,
365 * and release the reference held on the state's existing mode property, if any
369 * Zero on success, error code on failure. Cannot return -EDEADLK.
371 int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,
372 struct drm_property_blob *blob)
374 if (blob == state->mode_blob)
377 drm_property_unreference_blob(state->mode_blob);
378 state->mode_blob = NULL;
380 memset(&state->mode, 0, sizeof(state->mode));
383 if (blob->length != sizeof(struct drm_mode_modeinfo) ||
384 drm_mode_convert_umode(&state->mode,
385 (const struct drm_mode_modeinfo *)
389 state->mode_blob = drm_property_reference_blob(blob);
390 state->enable = true;
391 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
392 state->mode.name, state);
394 state->enable = false;
395 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
401 EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc);
404 * drm_atomic_replace_property_blob - replace a blob property
405 * @blob: a pointer to the member blob to be replaced
406 * @new_blob: the new blob to replace with
407 * @replaced: whether the blob has been replaced
410 * Zero on success, error code on failure
413 drm_atomic_replace_property_blob(struct drm_property_blob **blob,
414 struct drm_property_blob *new_blob,
417 struct drm_property_blob *old_blob = *blob;
419 if (old_blob == new_blob)
422 drm_property_unreference_blob(old_blob);
424 drm_property_reference_blob(new_blob);
432 drm_atomic_replace_property_blob_from_id(struct drm_crtc *crtc,
433 struct drm_property_blob **blob,
435 ssize_t expected_size,
438 struct drm_property_blob *new_blob = NULL;
441 new_blob = drm_property_lookup_blob(crtc->dev, blob_id);
442 if (new_blob == NULL)
445 if (expected_size > 0 && expected_size != new_blob->length) {
446 drm_property_unreference_blob(new_blob);
451 drm_atomic_replace_property_blob(blob, new_blob, replaced);
452 drm_property_unreference_blob(new_blob);
458 * drm_atomic_crtc_set_property - set property on CRTC
459 * @crtc: the drm CRTC to set a property on
460 * @state: the state object to update with the new property value
461 * @property: the property to set
462 * @val: the new property value
464 * Use this instead of calling crtc->atomic_set_property directly.
465 * This function handles generic/core properties and calls out to
466 * driver's ->atomic_set_property() for driver properties. To ensure
467 * consistent behavior you must call this function rather than the
468 * driver hook directly.
471 * Zero on success, error code on failure
473 int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
474 struct drm_crtc_state *state, struct drm_property *property,
477 struct drm_device *dev = crtc->dev;
478 struct drm_mode_config *config = &dev->mode_config;
479 bool replaced = false;
482 if (property == config->prop_active)
484 else if (property == config->prop_mode_id) {
485 struct drm_property_blob *mode =
486 drm_property_lookup_blob(dev, val);
487 ret = drm_atomic_set_mode_prop_for_crtc(state, mode);
488 drm_property_unreference_blob(mode);
490 } else if (property == config->degamma_lut_property) {
491 ret = drm_atomic_replace_property_blob_from_id(crtc,
496 state->color_mgmt_changed |= replaced;
498 } else if (property == config->ctm_property) {
499 ret = drm_atomic_replace_property_blob_from_id(crtc,
502 sizeof(struct drm_color_ctm),
504 state->color_mgmt_changed |= replaced;
506 } else if (property == config->gamma_lut_property) {
507 ret = drm_atomic_replace_property_blob_from_id(crtc,
512 state->color_mgmt_changed |= replaced;
514 } else if (property == config->prop_out_fence_ptr) {
515 s64 __user *fence_ptr = u64_to_user_ptr(val);
520 if (put_user(-1, fence_ptr))
523 set_out_fence_for_crtc(state->state, crtc, fence_ptr);
524 } else if (crtc->funcs->atomic_set_property)
525 return crtc->funcs->atomic_set_property(crtc, state, property, val);
531 EXPORT_SYMBOL(drm_atomic_crtc_set_property);
534 * drm_atomic_crtc_get_property - get property value from CRTC state
535 * @crtc: the drm CRTC to set a property on
536 * @state: the state object to get the property value from
537 * @property: the property to set
538 * @val: return location for the property value
540 * This function handles generic/core properties and calls out to
541 * driver's ->atomic_get_property() for driver properties. To ensure
542 * consistent behavior you must call this function rather than the
543 * driver hook directly.
546 * Zero on success, error code on failure
549 drm_atomic_crtc_get_property(struct drm_crtc *crtc,
550 const struct drm_crtc_state *state,
551 struct drm_property *property, uint64_t *val)
553 struct drm_device *dev = crtc->dev;
554 struct drm_mode_config *config = &dev->mode_config;
556 if (property == config->prop_active)
557 *val = state->active;
558 else if (property == config->prop_mode_id)
559 *val = (state->mode_blob) ? state->mode_blob->base.id : 0;
560 else if (property == config->degamma_lut_property)
561 *val = (state->degamma_lut) ? state->degamma_lut->base.id : 0;
562 else if (property == config->ctm_property)
563 *val = (state->ctm) ? state->ctm->base.id : 0;
564 else if (property == config->gamma_lut_property)
565 *val = (state->gamma_lut) ? state->gamma_lut->base.id : 0;
566 else if (property == config->prop_out_fence_ptr)
568 else if (crtc->funcs->atomic_get_property)
569 return crtc->funcs->atomic_get_property(crtc, state, property, val);
577 * drm_atomic_crtc_check - check crtc state
578 * @crtc: crtc to check
579 * @state: crtc state to check
581 * Provides core sanity checks for crtc state.
584 * Zero on success, error code on failure
586 static int drm_atomic_crtc_check(struct drm_crtc *crtc,
587 struct drm_crtc_state *state)
589 /* NOTE: we explicitly don't enforce constraints such as primary
590 * layer covering entire screen, since that is something we want
591 * to allow (on hw that supports it). For hw that does not, it
592 * should be checked in driver's crtc->atomic_check() vfunc.
594 * TODO: Add generic modeset state checks once we support those.
597 if (state->active && !state->enable) {
598 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active without enabled\n",
599 crtc->base.id, crtc->name);
603 /* The state->enable vs. state->mode_blob checks can be WARN_ON,
604 * as this is a kernel-internal detail that userspace should never
605 * be able to trigger. */
606 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
607 WARN_ON(state->enable && !state->mode_blob)) {
608 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled without mode blob\n",
609 crtc->base.id, crtc->name);
613 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
614 WARN_ON(!state->enable && state->mode_blob)) {
615 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled with mode blob\n",
616 crtc->base.id, crtc->name);
621 * Reject event generation for when a CRTC is off and stays off.
622 * It wouldn't be hard to implement this, but userspace has a track
623 * record of happily burning through 100% cpu (or worse, crash) when the
624 * display pipe is suspended. To avoid all that fun just reject updates
625 * that ask for events since likely that indicates a bug in the
626 * compositor's drawing loop. This is consistent with the vblank IOCTL
627 * and legacy page_flip IOCTL which also reject service on a disabled
630 if (state->event && !state->active && !crtc->state->active) {
631 DRM_DEBUG_ATOMIC("[CRTC:%d] requesting event but off\n",
639 static void drm_atomic_crtc_print_state(struct drm_printer *p,
640 const struct drm_crtc_state *state)
642 struct drm_crtc *crtc = state->crtc;
644 drm_printf(p, "crtc[%u]: %s\n", crtc->base.id, crtc->name);
645 drm_printf(p, "\tenable=%d\n", state->enable);
646 drm_printf(p, "\tactive=%d\n", state->active);
647 drm_printf(p, "\tplanes_changed=%d\n", state->planes_changed);
648 drm_printf(p, "\tmode_changed=%d\n", state->mode_changed);
649 drm_printf(p, "\tactive_changed=%d\n", state->active_changed);
650 drm_printf(p, "\tconnectors_changed=%d\n", state->connectors_changed);
651 drm_printf(p, "\tcolor_mgmt_changed=%d\n", state->color_mgmt_changed);
652 drm_printf(p, "\tplane_mask=%x\n", state->plane_mask);
653 drm_printf(p, "\tconnector_mask=%x\n", state->connector_mask);
654 drm_printf(p, "\tencoder_mask=%x\n", state->encoder_mask);
655 drm_printf(p, "\tmode: " DRM_MODE_FMT "\n", DRM_MODE_ARG(&state->mode));
657 if (crtc->funcs->atomic_print_state)
658 crtc->funcs->atomic_print_state(p, state);
662 * drm_atomic_get_plane_state - get plane state
663 * @state: global atomic state object
664 * @plane: plane to get state object for
666 * This function returns the plane state for the given plane, allocating it if
667 * needed. It will also grab the relevant plane lock to make sure that the state
672 * Either the allocated state or the error code encoded into the pointer. When
673 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
674 * entire atomic sequence must be restarted. All other errors are fatal.
676 struct drm_plane_state *
677 drm_atomic_get_plane_state(struct drm_atomic_state *state,
678 struct drm_plane *plane)
680 int ret, index = drm_plane_index(plane);
681 struct drm_plane_state *plane_state;
683 WARN_ON(!state->acquire_ctx);
685 plane_state = drm_atomic_get_existing_plane_state(state, plane);
689 ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx);
693 plane_state = plane->funcs->atomic_duplicate_state(plane);
695 return ERR_PTR(-ENOMEM);
697 state->planes[index].state = plane_state;
698 state->planes[index].ptr = plane;
699 plane_state->state = state;
701 DRM_DEBUG_ATOMIC("Added [PLANE:%d:%s] %p state to %p\n",
702 plane->base.id, plane->name, plane_state, state);
704 if (plane_state->crtc) {
705 struct drm_crtc_state *crtc_state;
707 crtc_state = drm_atomic_get_crtc_state(state,
709 if (IS_ERR(crtc_state))
710 return ERR_CAST(crtc_state);
715 EXPORT_SYMBOL(drm_atomic_get_plane_state);
718 * drm_atomic_plane_set_property - set property on plane
719 * @plane: the drm plane to set a property on
720 * @state: the state object to update with the new property value
721 * @property: the property to set
722 * @val: the new property value
724 * Use this instead of calling plane->atomic_set_property directly.
725 * This function handles generic/core properties and calls out to
726 * driver's ->atomic_set_property() for driver properties. To ensure
727 * consistent behavior you must call this function rather than the
728 * driver hook directly.
731 * Zero on success, error code on failure
733 int drm_atomic_plane_set_property(struct drm_plane *plane,
734 struct drm_plane_state *state, struct drm_property *property,
737 struct drm_device *dev = plane->dev;
738 struct drm_mode_config *config = &dev->mode_config;
740 if (property == config->prop_fb_id) {
741 struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, val);
742 drm_atomic_set_fb_for_plane(state, fb);
744 drm_framebuffer_unreference(fb);
745 } else if (property == config->prop_in_fence_fd) {
749 if (U642I64(val) == -1)
752 state->fence = sync_file_get_fence(val);
756 } else if (property == config->prop_crtc_id) {
757 struct drm_crtc *crtc = drm_crtc_find(dev, val);
758 return drm_atomic_set_crtc_for_plane(state, crtc);
759 } else if (property == config->prop_crtc_x) {
760 state->crtc_x = U642I64(val);
761 } else if (property == config->prop_crtc_y) {
762 state->crtc_y = U642I64(val);
763 } else if (property == config->prop_crtc_w) {
765 } else if (property == config->prop_crtc_h) {
767 } else if (property == config->prop_src_x) {
769 } else if (property == config->prop_src_y) {
771 } else if (property == config->prop_src_w) {
773 } else if (property == config->prop_src_h) {
775 } else if (property == plane->rotation_property) {
776 if (!is_power_of_2(val & DRM_ROTATE_MASK))
778 state->rotation = val;
779 } else if (property == plane->zpos_property) {
781 } else if (plane->funcs->atomic_set_property) {
782 return plane->funcs->atomic_set_property(plane, state,
790 EXPORT_SYMBOL(drm_atomic_plane_set_property);
793 * drm_atomic_plane_get_property - get property value from plane state
794 * @plane: the drm plane to set a property on
795 * @state: the state object to get the property value from
796 * @property: the property to set
797 * @val: return location for the property value
799 * This function handles generic/core properties and calls out to
800 * driver's ->atomic_get_property() for driver properties. To ensure
801 * consistent behavior you must call this function rather than the
802 * driver hook directly.
805 * Zero on success, error code on failure
808 drm_atomic_plane_get_property(struct drm_plane *plane,
809 const struct drm_plane_state *state,
810 struct drm_property *property, uint64_t *val)
812 struct drm_device *dev = plane->dev;
813 struct drm_mode_config *config = &dev->mode_config;
815 if (property == config->prop_fb_id) {
816 *val = (state->fb) ? state->fb->base.id : 0;
817 } else if (property == config->prop_in_fence_fd) {
819 } else if (property == config->prop_crtc_id) {
820 *val = (state->crtc) ? state->crtc->base.id : 0;
821 } else if (property == config->prop_crtc_x) {
822 *val = I642U64(state->crtc_x);
823 } else if (property == config->prop_crtc_y) {
824 *val = I642U64(state->crtc_y);
825 } else if (property == config->prop_crtc_w) {
826 *val = state->crtc_w;
827 } else if (property == config->prop_crtc_h) {
828 *val = state->crtc_h;
829 } else if (property == config->prop_src_x) {
831 } else if (property == config->prop_src_y) {
833 } else if (property == config->prop_src_w) {
835 } else if (property == config->prop_src_h) {
837 } else if (property == plane->rotation_property) {
838 *val = state->rotation;
839 } else if (property == plane->zpos_property) {
841 } else if (plane->funcs->atomic_get_property) {
842 return plane->funcs->atomic_get_property(plane, state, property, val);
851 plane_switching_crtc(struct drm_atomic_state *state,
852 struct drm_plane *plane,
853 struct drm_plane_state *plane_state)
855 if (!plane->state->crtc || !plane_state->crtc)
858 if (plane->state->crtc == plane_state->crtc)
861 /* This could be refined, but currently there's no helper or driver code
862 * to implement direct switching of active planes nor userspace to take
863 * advantage of more direct plane switching without the intermediate
870 * drm_atomic_plane_check - check plane state
871 * @plane: plane to check
872 * @state: plane state to check
874 * Provides core sanity checks for plane state.
877 * Zero on success, error code on failure
879 static int drm_atomic_plane_check(struct drm_plane *plane,
880 struct drm_plane_state *state)
882 unsigned int fb_width, fb_height;
885 /* either *both* CRTC and FB must be set, or neither */
886 if (WARN_ON(state->crtc && !state->fb)) {
887 DRM_DEBUG_ATOMIC("CRTC set but no FB\n");
889 } else if (WARN_ON(state->fb && !state->crtc)) {
890 DRM_DEBUG_ATOMIC("FB set but no CRTC\n");
894 /* if disabled, we don't care about the rest of the state: */
898 /* Check whether this plane is usable on this CRTC */
899 if (!(plane->possible_crtcs & drm_crtc_mask(state->crtc))) {
900 DRM_DEBUG_ATOMIC("Invalid crtc for plane\n");
904 /* Check whether this plane supports the fb pixel format. */
905 ret = drm_plane_check_pixel_format(plane, state->fb->pixel_format);
907 struct drm_format_name_buf format_name;
908 DRM_DEBUG_ATOMIC("Invalid pixel format %s\n",
909 drm_get_format_name(state->fb->pixel_format,
914 /* Give drivers some help against integer overflows */
915 if (state->crtc_w > INT_MAX ||
916 state->crtc_x > INT_MAX - (int32_t) state->crtc_w ||
917 state->crtc_h > INT_MAX ||
918 state->crtc_y > INT_MAX - (int32_t) state->crtc_h) {
919 DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n",
920 state->crtc_w, state->crtc_h,
921 state->crtc_x, state->crtc_y);
925 fb_width = state->fb->width << 16;
926 fb_height = state->fb->height << 16;
928 /* Make sure source coordinates are inside the fb. */
929 if (state->src_w > fb_width ||
930 state->src_x > fb_width - state->src_w ||
931 state->src_h > fb_height ||
932 state->src_y > fb_height - state->src_h) {
933 DRM_DEBUG_ATOMIC("Invalid source coordinates "
934 "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
935 state->src_w >> 16, ((state->src_w & 0xffff) * 15625) >> 10,
936 state->src_h >> 16, ((state->src_h & 0xffff) * 15625) >> 10,
937 state->src_x >> 16, ((state->src_x & 0xffff) * 15625) >> 10,
938 state->src_y >> 16, ((state->src_y & 0xffff) * 15625) >> 10);
942 if (plane_switching_crtc(state->state, plane, state)) {
943 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] switching CRTC directly\n",
944 plane->base.id, plane->name);
951 static void drm_atomic_plane_print_state(struct drm_printer *p,
952 const struct drm_plane_state *state)
954 struct drm_plane *plane = state->plane;
955 struct drm_rect src = drm_plane_state_src(state);
956 struct drm_rect dest = drm_plane_state_dest(state);
958 drm_printf(p, "plane[%u]: %s\n", plane->base.id, plane->name);
959 drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)");
960 drm_printf(p, "\tfb=%u\n", state->fb ? state->fb->base.id : 0);
962 struct drm_framebuffer *fb = state->fb;
963 int i, n = drm_format_num_planes(fb->pixel_format);
964 struct drm_format_name_buf format_name;
966 drm_printf(p, "\t\tformat=%s\n",
967 drm_get_format_name(fb->pixel_format, &format_name));
968 drm_printf(p, "\t\tsize=%dx%d\n", fb->width, fb->height);
969 drm_printf(p, "\t\tlayers:\n");
970 for (i = 0; i < n; i++) {
971 drm_printf(p, "\t\t\tpitch[%d]=%u\n", i, fb->pitches[i]);
972 drm_printf(p, "\t\t\toffset[%d]=%u\n", i, fb->offsets[i]);
973 drm_printf(p, "\t\t\tmodifier[%d]=0x%llx\n", i, fb->modifier[i]);
976 drm_printf(p, "\tcrtc-pos=" DRM_RECT_FMT "\n", DRM_RECT_ARG(&dest));
977 drm_printf(p, "\tsrc-pos=" DRM_RECT_FP_FMT "\n", DRM_RECT_FP_ARG(&src));
978 drm_printf(p, "\trotation=%x\n", state->rotation);
980 if (plane->funcs->atomic_print_state)
981 plane->funcs->atomic_print_state(p, state);
985 * drm_atomic_get_connector_state - get connector state
986 * @state: global atomic state object
987 * @connector: connector to get state object for
989 * This function returns the connector state for the given connector,
990 * allocating it if needed. It will also grab the relevant connector lock to
991 * make sure that the state is consistent.
995 * Either the allocated state or the error code encoded into the pointer. When
996 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
997 * entire atomic sequence must be restarted. All other errors are fatal.
999 struct drm_connector_state *
1000 drm_atomic_get_connector_state(struct drm_atomic_state *state,
1001 struct drm_connector *connector)
1004 struct drm_mode_config *config = &connector->dev->mode_config;
1005 struct drm_connector_state *connector_state;
1007 WARN_ON(!state->acquire_ctx);
1009 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
1011 return ERR_PTR(ret);
1013 index = drm_connector_index(connector);
1015 if (index >= state->num_connector) {
1016 struct __drm_connnectors_state *c;
1017 int alloc = max(index + 1, config->num_connector);
1019 c = krealloc(state->connectors, alloc * sizeof(*state->connectors), GFP_KERNEL);
1021 return ERR_PTR(-ENOMEM);
1023 state->connectors = c;
1024 memset(&state->connectors[state->num_connector], 0,
1025 sizeof(*state->connectors) * (alloc - state->num_connector));
1027 state->num_connector = alloc;
1030 if (state->connectors[index].state)
1031 return state->connectors[index].state;
1033 connector_state = connector->funcs->atomic_duplicate_state(connector);
1034 if (!connector_state)
1035 return ERR_PTR(-ENOMEM);
1037 drm_connector_reference(connector);
1038 state->connectors[index].state = connector_state;
1039 state->connectors[index].ptr = connector;
1040 connector_state->state = state;
1042 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d] %p state to %p\n",
1043 connector->base.id, connector_state, state);
1045 if (connector_state->crtc) {
1046 struct drm_crtc_state *crtc_state;
1048 crtc_state = drm_atomic_get_crtc_state(state,
1049 connector_state->crtc);
1050 if (IS_ERR(crtc_state))
1051 return ERR_CAST(crtc_state);
1054 return connector_state;
1056 EXPORT_SYMBOL(drm_atomic_get_connector_state);
1059 * drm_atomic_connector_set_property - set property on connector.
1060 * @connector: the drm connector to set a property on
1061 * @state: the state object to update with the new property value
1062 * @property: the property to set
1063 * @val: the new property value
1065 * Use this instead of calling connector->atomic_set_property directly.
1066 * This function handles generic/core properties and calls out to
1067 * driver's ->atomic_set_property() for driver properties. To ensure
1068 * consistent behavior you must call this function rather than the
1069 * driver hook directly.
1072 * Zero on success, error code on failure
1074 int drm_atomic_connector_set_property(struct drm_connector *connector,
1075 struct drm_connector_state *state, struct drm_property *property,
1078 struct drm_device *dev = connector->dev;
1079 struct drm_mode_config *config = &dev->mode_config;
1081 if (property == config->prop_crtc_id) {
1082 struct drm_crtc *crtc = drm_crtc_find(dev, val);
1083 return drm_atomic_set_crtc_for_connector(state, crtc);
1084 } else if (property == config->dpms_property) {
1085 /* setting DPMS property requires special handling, which
1086 * is done in legacy setprop path for us. Disallow (for
1087 * now?) atomic writes to DPMS property:
1090 } else if (connector->funcs->atomic_set_property) {
1091 return connector->funcs->atomic_set_property(connector,
1092 state, property, val);
1097 EXPORT_SYMBOL(drm_atomic_connector_set_property);
1099 static void drm_atomic_connector_print_state(struct drm_printer *p,
1100 const struct drm_connector_state *state)
1102 struct drm_connector *connector = state->connector;
1104 drm_printf(p, "connector[%u]: %s\n", connector->base.id, connector->name);
1105 drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)");
1107 if (connector->funcs->atomic_print_state)
1108 connector->funcs->atomic_print_state(p, state);
1112 * drm_atomic_connector_get_property - get property value from connector state
1113 * @connector: the drm connector to set a property on
1114 * @state: the state object to get the property value from
1115 * @property: the property to set
1116 * @val: return location for the property value
1118 * This function handles generic/core properties and calls out to
1119 * driver's ->atomic_get_property() for driver properties. To ensure
1120 * consistent behavior you must call this function rather than the
1121 * driver hook directly.
1124 * Zero on success, error code on failure
1127 drm_atomic_connector_get_property(struct drm_connector *connector,
1128 const struct drm_connector_state *state,
1129 struct drm_property *property, uint64_t *val)
1131 struct drm_device *dev = connector->dev;
1132 struct drm_mode_config *config = &dev->mode_config;
1134 if (property == config->prop_crtc_id) {
1135 *val = (state->crtc) ? state->crtc->base.id : 0;
1136 } else if (property == config->dpms_property) {
1137 *val = connector->dpms;
1138 } else if (connector->funcs->atomic_get_property) {
1139 return connector->funcs->atomic_get_property(connector,
1140 state, property, val);
1148 int drm_atomic_get_property(struct drm_mode_object *obj,
1149 struct drm_property *property, uint64_t *val)
1151 struct drm_device *dev = property->dev;
1154 switch (obj->type) {
1155 case DRM_MODE_OBJECT_CONNECTOR: {
1156 struct drm_connector *connector = obj_to_connector(obj);
1157 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
1158 ret = drm_atomic_connector_get_property(connector,
1159 connector->state, property, val);
1162 case DRM_MODE_OBJECT_CRTC: {
1163 struct drm_crtc *crtc = obj_to_crtc(obj);
1164 WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
1165 ret = drm_atomic_crtc_get_property(crtc,
1166 crtc->state, property, val);
1169 case DRM_MODE_OBJECT_PLANE: {
1170 struct drm_plane *plane = obj_to_plane(obj);
1171 WARN_ON(!drm_modeset_is_locked(&plane->mutex));
1172 ret = drm_atomic_plane_get_property(plane,
1173 plane->state, property, val);
1185 * drm_atomic_set_crtc_for_plane - set crtc for plane
1186 * @plane_state: the plane whose incoming state to update
1187 * @crtc: crtc to use for the plane
1189 * Changing the assigned crtc for a plane requires us to grab the lock and state
1190 * for the new crtc, as needed. This function takes care of all these details
1191 * besides updating the pointer in the state object itself.
1194 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1195 * then the w/w mutex code has detected a deadlock and the entire atomic
1196 * sequence must be restarted. All other errors are fatal.
1199 drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
1200 struct drm_crtc *crtc)
1202 struct drm_plane *plane = plane_state->plane;
1203 struct drm_crtc_state *crtc_state;
1205 if (plane_state->crtc) {
1206 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
1208 if (WARN_ON(IS_ERR(crtc_state)))
1209 return PTR_ERR(crtc_state);
1211 crtc_state->plane_mask &= ~(1 << drm_plane_index(plane));
1214 plane_state->crtc = crtc;
1217 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
1219 if (IS_ERR(crtc_state))
1220 return PTR_ERR(crtc_state);
1221 crtc_state->plane_mask |= (1 << drm_plane_index(plane));
1225 DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d:%s]\n",
1226 plane_state, crtc->base.id, crtc->name);
1228 DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n",
1233 EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane);
1236 * drm_atomic_set_fb_for_plane - set framebuffer for plane
1237 * @plane_state: atomic state object for the plane
1238 * @fb: fb to use for the plane
1240 * Changing the assigned framebuffer for a plane requires us to grab a reference
1241 * to the new fb and drop the reference to the old fb, if there is one. This
1242 * function takes care of all these details besides updating the pointer in the
1243 * state object itself.
1246 drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
1247 struct drm_framebuffer *fb)
1249 if (plane_state->fb)
1250 drm_framebuffer_unreference(plane_state->fb);
1252 drm_framebuffer_reference(fb);
1253 plane_state->fb = fb;
1256 DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n",
1257 fb->base.id, plane_state);
1259 DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n",
1262 EXPORT_SYMBOL(drm_atomic_set_fb_for_plane);
1265 * drm_atomic_set_fence_for_plane - set fence for plane
1266 * @plane_state: atomic state object for the plane
1267 * @fence: dma_fence to use for the plane
1269 * Helper to setup the plane_state fence in case it is not set yet.
1270 * By using this drivers doesn't need to worry if the user choose
1271 * implicit or explicit fencing.
1273 * This function will not set the fence to the state if it was set
1274 * via explicit fencing interfaces on the atomic ioctl. It will
1275 * all drope the reference to the fence as we not storing it
1278 * Otherwise, if plane_state->fence is not set this function we
1279 * just set it with the received implict fence.
1282 drm_atomic_set_fence_for_plane(struct drm_plane_state *plane_state,
1283 struct dma_fence *fence)
1285 if (plane_state->fence) {
1286 dma_fence_put(fence);
1290 plane_state->fence = fence;
1292 EXPORT_SYMBOL(drm_atomic_set_fence_for_plane);
1295 * drm_atomic_set_crtc_for_connector - set crtc for connector
1296 * @conn_state: atomic state object for the connector
1297 * @crtc: crtc to use for the connector
1299 * Changing the assigned crtc for a connector requires us to grab the lock and
1300 * state for the new crtc, as needed. This function takes care of all these
1301 * details besides updating the pointer in the state object itself.
1304 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1305 * then the w/w mutex code has detected a deadlock and the entire atomic
1306 * sequence must be restarted. All other errors are fatal.
1309 drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
1310 struct drm_crtc *crtc)
1312 struct drm_crtc_state *crtc_state;
1314 if (conn_state->crtc == crtc)
1317 if (conn_state->crtc) {
1318 crtc_state = drm_atomic_get_existing_crtc_state(conn_state->state,
1321 crtc_state->connector_mask &=
1322 ~(1 << drm_connector_index(conn_state->connector));
1324 drm_connector_unreference(conn_state->connector);
1325 conn_state->crtc = NULL;
1329 crtc_state = drm_atomic_get_crtc_state(conn_state->state, crtc);
1330 if (IS_ERR(crtc_state))
1331 return PTR_ERR(crtc_state);
1333 crtc_state->connector_mask |=
1334 1 << drm_connector_index(conn_state->connector);
1336 drm_connector_reference(conn_state->connector);
1337 conn_state->crtc = crtc;
1339 DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d:%s]\n",
1340 conn_state, crtc->base.id, crtc->name);
1342 DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n",
1348 EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector);
1351 * drm_atomic_add_affected_connectors - add connectors for crtc
1352 * @state: atomic state
1355 * This function walks the current configuration and adds all connectors
1356 * currently using @crtc to the atomic configuration @state. Note that this
1357 * function must acquire the connection mutex. This can potentially cause
1358 * unneeded seralization if the update is just for the planes on one crtc. Hence
1359 * drivers and helpers should only call this when really needed (e.g. when a
1360 * full modeset needs to happen due to some change).
1363 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1364 * then the w/w mutex code has detected a deadlock and the entire atomic
1365 * sequence must be restarted. All other errors are fatal.
1368 drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
1369 struct drm_crtc *crtc)
1371 struct drm_mode_config *config = &state->dev->mode_config;
1372 struct drm_connector *connector;
1373 struct drm_connector_state *conn_state;
1376 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
1380 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %p\n",
1381 crtc->base.id, crtc->name, state);
1384 * Changed connectors are already in @state, so only need to look at the
1385 * current configuration.
1387 drm_for_each_connector(connector, state->dev) {
1388 if (connector->state->crtc != crtc)
1391 conn_state = drm_atomic_get_connector_state(state, connector);
1392 if (IS_ERR(conn_state))
1393 return PTR_ERR(conn_state);
1398 EXPORT_SYMBOL(drm_atomic_add_affected_connectors);
1401 * drm_atomic_add_affected_planes - add planes for crtc
1402 * @state: atomic state
1405 * This function walks the current configuration and adds all planes
1406 * currently used by @crtc to the atomic configuration @state. This is useful
1407 * when an atomic commit also needs to check all currently enabled plane on
1408 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1409 * to avoid special code to force-enable all planes.
1411 * Since acquiring a plane state will always also acquire the w/w mutex of the
1412 * current CRTC for that plane (if there is any) adding all the plane states for
1413 * a CRTC will not reduce parallism of atomic updates.
1416 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1417 * then the w/w mutex code has detected a deadlock and the entire atomic
1418 * sequence must be restarted. All other errors are fatal.
1421 drm_atomic_add_affected_planes(struct drm_atomic_state *state,
1422 struct drm_crtc *crtc)
1424 struct drm_plane *plane;
1426 WARN_ON(!drm_atomic_get_existing_crtc_state(state, crtc));
1428 drm_for_each_plane_mask(plane, state->dev, crtc->state->plane_mask) {
1429 struct drm_plane_state *plane_state =
1430 drm_atomic_get_plane_state(state, plane);
1432 if (IS_ERR(plane_state))
1433 return PTR_ERR(plane_state);
1437 EXPORT_SYMBOL(drm_atomic_add_affected_planes);
1440 * drm_atomic_legacy_backoff - locking backoff for legacy ioctls
1441 * @state: atomic state
1443 * This function should be used by legacy entry points which don't understand
1444 * -EDEADLK semantics. For simplicity this one will grab all modeset locks after
1445 * the slowpath completed.
1447 void drm_atomic_legacy_backoff(struct drm_atomic_state *state)
1449 struct drm_device *dev = state->dev;
1450 unsigned crtc_mask = 0;
1451 struct drm_crtc *crtc;
1453 bool global = false;
1455 drm_for_each_crtc(crtc, dev) {
1456 if (crtc->acquire_ctx != state->acquire_ctx)
1459 crtc_mask |= drm_crtc_mask(crtc);
1460 crtc->acquire_ctx = NULL;
1463 if (WARN_ON(dev->mode_config.acquire_ctx == state->acquire_ctx)) {
1466 dev->mode_config.acquire_ctx = NULL;
1470 drm_modeset_backoff(state->acquire_ctx);
1472 ret = drm_modeset_lock_all_ctx(dev, state->acquire_ctx);
1476 drm_for_each_crtc(crtc, dev)
1477 if (drm_crtc_mask(crtc) & crtc_mask)
1478 crtc->acquire_ctx = state->acquire_ctx;
1481 dev->mode_config.acquire_ctx = state->acquire_ctx;
1483 EXPORT_SYMBOL(drm_atomic_legacy_backoff);
1486 * drm_atomic_check_only - check whether a given config would work
1487 * @state: atomic configuration to check
1489 * Note that this function can return -EDEADLK if the driver needed to acquire
1490 * more locks but encountered a deadlock. The caller must then do the usual w/w
1491 * backoff dance and restart. All other errors are fatal.
1494 * 0 on success, negative error code on failure.
1496 int drm_atomic_check_only(struct drm_atomic_state *state)
1498 struct drm_device *dev = state->dev;
1499 struct drm_mode_config *config = &dev->mode_config;
1500 struct drm_plane *plane;
1501 struct drm_plane_state *plane_state;
1502 struct drm_crtc *crtc;
1503 struct drm_crtc_state *crtc_state;
1506 DRM_DEBUG_ATOMIC("checking %p\n", state);
1508 for_each_plane_in_state(state, plane, plane_state, i) {
1509 ret = drm_atomic_plane_check(plane, plane_state);
1511 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic core check failed\n",
1512 plane->base.id, plane->name);
1517 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1518 ret = drm_atomic_crtc_check(crtc, crtc_state);
1520 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic core check failed\n",
1521 crtc->base.id, crtc->name);
1526 if (config->funcs->atomic_check)
1527 ret = config->funcs->atomic_check(state->dev, state);
1529 if (!state->allow_modeset) {
1530 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1531 if (drm_atomic_crtc_needs_modeset(crtc_state)) {
1532 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requires full modeset\n",
1533 crtc->base.id, crtc->name);
1541 EXPORT_SYMBOL(drm_atomic_check_only);
1544 * drm_atomic_commit - commit configuration atomically
1545 * @state: atomic configuration to check
1547 * Note that this function can return -EDEADLK if the driver needed to acquire
1548 * more locks but encountered a deadlock. The caller must then do the usual w/w
1549 * backoff dance and restart. All other errors are fatal.
1551 * Also note that on successful execution ownership of @state is transferred
1552 * from the caller of this function to the function itself. The caller must not
1553 * free or in any other way access @state. If the function fails then the caller
1554 * must clean up @state itself.
1557 * 0 on success, negative error code on failure.
1559 int drm_atomic_commit(struct drm_atomic_state *state)
1561 struct drm_mode_config *config = &state->dev->mode_config;
1564 ret = drm_atomic_check_only(state);
1568 DRM_DEBUG_ATOMIC("commiting %p\n", state);
1570 return config->funcs->atomic_commit(state->dev, state, false);
1572 EXPORT_SYMBOL(drm_atomic_commit);
1575 * drm_atomic_nonblocking_commit - atomic&nonblocking configuration commit
1576 * @state: atomic configuration to check
1578 * Note that this function can return -EDEADLK if the driver needed to acquire
1579 * more locks but encountered a deadlock. The caller must then do the usual w/w
1580 * backoff dance and restart. All other errors are fatal.
1582 * Also note that on successful execution ownership of @state is transferred
1583 * from the caller of this function to the function itself. The caller must not
1584 * free or in any other way access @state. If the function fails then the caller
1585 * must clean up @state itself.
1588 * 0 on success, negative error code on failure.
1590 int drm_atomic_nonblocking_commit(struct drm_atomic_state *state)
1592 struct drm_mode_config *config = &state->dev->mode_config;
1595 ret = drm_atomic_check_only(state);
1599 DRM_DEBUG_ATOMIC("commiting %p nonblocking\n", state);
1601 return config->funcs->atomic_commit(state->dev, state, true);
1603 EXPORT_SYMBOL(drm_atomic_nonblocking_commit);
1605 static void drm_atomic_print_state(const struct drm_atomic_state *state)
1607 struct drm_printer p = drm_info_printer(state->dev->dev);
1608 struct drm_plane *plane;
1609 struct drm_plane_state *plane_state;
1610 struct drm_crtc *crtc;
1611 struct drm_crtc_state *crtc_state;
1612 struct drm_connector *connector;
1613 struct drm_connector_state *connector_state;
1616 DRM_DEBUG_ATOMIC("checking %p\n", state);
1618 for_each_plane_in_state(state, plane, plane_state, i)
1619 drm_atomic_plane_print_state(&p, plane_state);
1621 for_each_crtc_in_state(state, crtc, crtc_state, i)
1622 drm_atomic_crtc_print_state(&p, crtc_state);
1624 for_each_connector_in_state(state, connector, connector_state, i)
1625 drm_atomic_connector_print_state(&p, connector_state);
1629 * drm_state_dump - dump entire device atomic state
1630 * @dev: the drm device
1631 * @p: where to print the state to
1633 * Just for debugging. Drivers might want an option to dump state
1634 * to dmesg in case of error irq's. (Hint, you probably want to
1637 * The caller must drm_modeset_lock_all(), or if this is called
1638 * from error irq handler, it should not be enabled by default.
1639 * (Ie. if you are debugging errors you might not care that this
1640 * is racey. But calling this without all modeset locks held is
1641 * not inherently safe.)
1643 void drm_state_dump(struct drm_device *dev, struct drm_printer *p)
1645 struct drm_mode_config *config = &dev->mode_config;
1646 struct drm_plane *plane;
1647 struct drm_crtc *crtc;
1648 struct drm_connector *connector;
1650 if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
1653 list_for_each_entry(plane, &config->plane_list, head)
1654 drm_atomic_plane_print_state(p, plane->state);
1656 list_for_each_entry(crtc, &config->crtc_list, head)
1657 drm_atomic_crtc_print_state(p, crtc->state);
1659 list_for_each_entry(connector, &config->connector_list, head)
1660 drm_atomic_connector_print_state(p, connector->state);
1662 EXPORT_SYMBOL(drm_state_dump);
1664 #ifdef CONFIG_DEBUG_FS
1665 static int drm_state_info(struct seq_file *m, void *data)
1667 struct drm_info_node *node = (struct drm_info_node *) m->private;
1668 struct drm_device *dev = node->minor->dev;
1669 struct drm_printer p = drm_seq_file_printer(m);
1671 drm_modeset_lock_all(dev);
1672 drm_state_dump(dev, &p);
1673 drm_modeset_unlock_all(dev);
1678 /* any use in debugfs files to dump individual planes/crtc/etc? */
1679 static const struct drm_info_list drm_atomic_debugfs_list[] = {
1680 {"state", drm_state_info, 0},
1683 int drm_atomic_debugfs_init(struct drm_minor *minor)
1685 return drm_debugfs_create_files(drm_atomic_debugfs_list,
1686 ARRAY_SIZE(drm_atomic_debugfs_list),
1687 minor->debugfs_root, minor);
1692 * The big monstor ioctl
1695 static struct drm_pending_vblank_event *create_vblank_event(
1696 struct drm_device *dev, uint64_t user_data)
1698 struct drm_pending_vblank_event *e = NULL;
1700 e = kzalloc(sizeof *e, GFP_KERNEL);
1704 e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
1705 e->event.base.length = sizeof(e->event);
1706 e->event.user_data = user_data;
1711 static int atomic_set_prop(struct drm_atomic_state *state,
1712 struct drm_mode_object *obj, struct drm_property *prop,
1713 uint64_t prop_value)
1715 struct drm_mode_object *ref;
1718 if (!drm_property_change_valid_get(prop, prop_value, &ref))
1721 switch (obj->type) {
1722 case DRM_MODE_OBJECT_CONNECTOR: {
1723 struct drm_connector *connector = obj_to_connector(obj);
1724 struct drm_connector_state *connector_state;
1726 connector_state = drm_atomic_get_connector_state(state, connector);
1727 if (IS_ERR(connector_state)) {
1728 ret = PTR_ERR(connector_state);
1732 ret = drm_atomic_connector_set_property(connector,
1733 connector_state, prop, prop_value);
1736 case DRM_MODE_OBJECT_CRTC: {
1737 struct drm_crtc *crtc = obj_to_crtc(obj);
1738 struct drm_crtc_state *crtc_state;
1740 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1741 if (IS_ERR(crtc_state)) {
1742 ret = PTR_ERR(crtc_state);
1746 ret = drm_atomic_crtc_set_property(crtc,
1747 crtc_state, prop, prop_value);
1750 case DRM_MODE_OBJECT_PLANE: {
1751 struct drm_plane *plane = obj_to_plane(obj);
1752 struct drm_plane_state *plane_state;
1754 plane_state = drm_atomic_get_plane_state(state, plane);
1755 if (IS_ERR(plane_state)) {
1756 ret = PTR_ERR(plane_state);
1760 ret = drm_atomic_plane_set_property(plane,
1761 plane_state, prop, prop_value);
1769 drm_property_change_valid_put(prop, ref);
1774 * drm_atomic_clean_old_fb -- Unset old_fb pointers and set plane->fb pointers.
1776 * @dev: drm device to check.
1777 * @plane_mask: plane mask for planes that were updated.
1778 * @ret: return value, can be -EDEADLK for a retry.
1780 * Before doing an update plane->old_fb is set to plane->fb,
1781 * but before dropping the locks old_fb needs to be set to NULL
1782 * and plane->fb updated. This is a common operation for each
1783 * atomic update, so this call is split off as a helper.
1785 void drm_atomic_clean_old_fb(struct drm_device *dev,
1786 unsigned plane_mask,
1789 struct drm_plane *plane;
1791 /* if succeeded, fixup legacy plane crtc/fb ptrs before dropping
1792 * locks (ie. while it is still safe to deref plane->state). We
1793 * need to do this here because the driver entry points cannot
1794 * distinguish between legacy and atomic ioctls.
1796 drm_for_each_plane_mask(plane, dev, plane_mask) {
1798 struct drm_framebuffer *new_fb = plane->state->fb;
1800 drm_framebuffer_reference(new_fb);
1802 plane->crtc = plane->state->crtc;
1805 drm_framebuffer_unreference(plane->old_fb);
1807 plane->old_fb = NULL;
1810 EXPORT_SYMBOL(drm_atomic_clean_old_fb);
1812 static struct dma_fence *get_crtc_fence(struct drm_crtc *crtc)
1814 struct dma_fence *fence;
1816 fence = kzalloc(sizeof(*fence), GFP_KERNEL);
1820 dma_fence_init(fence, &drm_crtc_fence_ops, &crtc->fence_lock,
1821 crtc->fence_context, ++crtc->fence_seqno);
1826 struct drm_out_fence_state {
1827 s64 __user *out_fence_ptr;
1828 struct sync_file *sync_file;
1832 static int setup_out_fence(struct drm_out_fence_state *fence_state,
1833 struct dma_fence *fence)
1835 fence_state->fd = get_unused_fd_flags(O_CLOEXEC);
1836 if (fence_state->fd < 0)
1837 return fence_state->fd;
1839 if (put_user(fence_state->fd, fence_state->out_fence_ptr))
1842 fence_state->sync_file = sync_file_create(fence);
1843 if (!fence_state->sync_file)
1849 static int prepare_crtc_signaling(struct drm_device *dev,
1850 struct drm_atomic_state *state,
1851 struct drm_mode_atomic *arg,
1852 struct drm_file *file_priv,
1853 struct drm_out_fence_state **fence_state,
1854 unsigned int *num_fences)
1856 struct drm_crtc *crtc;
1857 struct drm_crtc_state *crtc_state;
1860 if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)
1863 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1864 u64 __user *fence_ptr;
1866 fence_ptr = get_out_fence_for_crtc(crtc_state->state, crtc);
1868 if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT || fence_ptr) {
1869 struct drm_pending_vblank_event *e;
1871 e = create_vblank_event(dev, arg->user_data);
1875 crtc_state->event = e;
1878 if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1879 struct drm_pending_vblank_event *e = crtc_state->event;
1884 ret = drm_event_reserve_init(dev, file_priv, &e->base,
1888 crtc_state->event = NULL;
1894 struct dma_fence *fence;
1895 struct drm_out_fence_state *f;
1897 f = krealloc(*fence_state, sizeof(**fence_state) *
1898 (*num_fences + 1), GFP_KERNEL);
1902 memset(&f[*num_fences], 0, sizeof(*f));
1904 f[*num_fences].out_fence_ptr = fence_ptr;
1907 fence = get_crtc_fence(crtc);
1911 ret = setup_out_fence(&f[(*num_fences)++], fence);
1913 dma_fence_put(fence);
1917 crtc_state->event->base.fence = fence;
1924 static void complete_crtc_signaling(struct drm_device *dev,
1925 struct drm_atomic_state *state,
1926 struct drm_out_fence_state *fence_state,
1927 unsigned int num_fences,
1930 struct drm_crtc *crtc;
1931 struct drm_crtc_state *crtc_state;
1935 for (i = 0; i < num_fences; i++)
1936 fd_install(fence_state[i].fd,
1937 fence_state[i].sync_file->file);
1943 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1945 * TEST_ONLY and PAGE_FLIP_EVENT are mutually
1946 * exclusive, if they weren't, this code should be
1947 * called on success for TEST_ONLY too.
1949 if (crtc_state->event)
1950 drm_event_cancel_free(dev, &crtc_state->event->base);
1956 for (i = 0; i < num_fences; i++) {
1957 if (fence_state[i].sync_file)
1958 fput(fence_state[i].sync_file->file);
1959 if (fence_state[i].fd >= 0)
1960 put_unused_fd(fence_state[i].fd);
1962 /* If this fails log error to the user */
1963 if (fence_state[i].out_fence_ptr &&
1964 put_user(-1, fence_state[i].out_fence_ptr))
1965 DRM_DEBUG_ATOMIC("Couldn't clear out_fence_ptr\n");
1971 int drm_mode_atomic_ioctl(struct drm_device *dev,
1972 void *data, struct drm_file *file_priv)
1974 struct drm_mode_atomic *arg = data;
1975 uint32_t __user *objs_ptr = (uint32_t __user *)(unsigned long)(arg->objs_ptr);
1976 uint32_t __user *count_props_ptr = (uint32_t __user *)(unsigned long)(arg->count_props_ptr);
1977 uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
1978 uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr);
1979 unsigned int copied_objs, copied_props;
1980 struct drm_atomic_state *state;
1981 struct drm_modeset_acquire_ctx ctx;
1982 struct drm_plane *plane;
1983 struct drm_out_fence_state *fence_state = NULL;
1984 unsigned plane_mask;
1986 unsigned int i, j, num_fences = 0;
1988 /* disallow for drivers not supporting atomic: */
1989 if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
1992 /* disallow for userspace that has not enabled atomic cap (even
1993 * though this may be a bit overkill, since legacy userspace
1994 * wouldn't know how to call this ioctl)
1996 if (!file_priv->atomic)
1999 if (arg->flags & ~DRM_MODE_ATOMIC_FLAGS)
2005 if ((arg->flags & DRM_MODE_PAGE_FLIP_ASYNC) &&
2006 !dev->mode_config.async_page_flip)
2009 /* can't test and expect an event at the same time. */
2010 if ((arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) &&
2011 (arg->flags & DRM_MODE_PAGE_FLIP_EVENT))
2014 drm_modeset_acquire_init(&ctx, 0);
2016 state = drm_atomic_state_alloc(dev);
2020 state->acquire_ctx = &ctx;
2021 state->allow_modeset = !!(arg->flags & DRM_MODE_ATOMIC_ALLOW_MODESET);
2028 for (i = 0; i < arg->count_objs; i++) {
2029 uint32_t obj_id, count_props;
2030 struct drm_mode_object *obj;
2032 if (get_user(obj_id, objs_ptr + copied_objs)) {
2037 obj = drm_mode_object_find(dev, obj_id, DRM_MODE_OBJECT_ANY);
2043 if (!obj->properties) {
2044 drm_mode_object_unreference(obj);
2049 if (get_user(count_props, count_props_ptr + copied_objs)) {
2050 drm_mode_object_unreference(obj);
2057 for (j = 0; j < count_props; j++) {
2059 uint64_t prop_value;
2060 struct drm_property *prop;
2062 if (get_user(prop_id, props_ptr + copied_props)) {
2063 drm_mode_object_unreference(obj);
2068 prop = drm_mode_obj_find_prop_id(obj, prop_id);
2070 drm_mode_object_unreference(obj);
2075 if (copy_from_user(&prop_value,
2076 prop_values_ptr + copied_props,
2077 sizeof(prop_value))) {
2078 drm_mode_object_unreference(obj);
2083 ret = atomic_set_prop(state, obj, prop, prop_value);
2085 drm_mode_object_unreference(obj);
2092 if (obj->type == DRM_MODE_OBJECT_PLANE && count_props &&
2093 !(arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)) {
2094 plane = obj_to_plane(obj);
2095 plane_mask |= (1 << drm_plane_index(plane));
2096 plane->old_fb = plane->fb;
2098 drm_mode_object_unreference(obj);
2101 ret = prepare_crtc_signaling(dev, state, arg, file_priv, &fence_state,
2106 if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) {
2108 * Unlike commit, check_only does not clean up state.
2109 * Below we call drm_atomic_state_put for it.
2111 ret = drm_atomic_check_only(state);
2112 } else if (arg->flags & DRM_MODE_ATOMIC_NONBLOCK) {
2113 ret = drm_atomic_nonblocking_commit(state);
2115 if (unlikely(drm_debug & DRM_UT_STATE))
2116 drm_atomic_print_state(state);
2118 ret = drm_atomic_commit(state);
2122 drm_atomic_clean_old_fb(dev, plane_mask, ret);
2124 complete_crtc_signaling(dev, state, fence_state, num_fences, !ret);
2126 if (ret == -EDEADLK) {
2127 drm_atomic_state_clear(state);
2128 drm_modeset_backoff(&ctx);
2132 drm_atomic_state_put(state);
2134 drm_modeset_drop_locks(&ctx);
2135 drm_modeset_acquire_fini(&ctx);