2 * Copyright (C) 2014 Red Hat
3 * Copyright (C) 2014 Intel Corp.
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
24 * Rob Clark <robdclark@gmail.com>
25 * Daniel Vetter <daniel.vetter@ffwll.ch>
30 #include <drm/drm_atomic.h>
31 #include <drm/drm_mode.h>
32 #include <drm/drm_plane_helper.h>
34 #include "drm_crtc_internal.h"
37 * drm_atomic_state_default_release -
38 * release memory initialized by drm_atomic_state_init
39 * @state: atomic state
41 * Free all the memory allocated by drm_atomic_state_init.
42 * This is useful for drivers that subclass the atomic state.
44 void drm_atomic_state_default_release(struct drm_atomic_state *state)
46 kfree(state->connectors);
47 kfree(state->connector_states);
49 kfree(state->crtc_states);
51 kfree(state->plane_states);
53 EXPORT_SYMBOL(drm_atomic_state_default_release);
56 * drm_atomic_state_init - init new atomic state
58 * @state: atomic state
60 * Default implementation for filling in a new atomic state.
61 * This is useful for drivers that subclass the atomic state.
64 drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state)
66 /* TODO legacy paths should maybe do a better job about
67 * setting this appropriately?
69 state->allow_modeset = true;
71 state->crtcs = kcalloc(dev->mode_config.num_crtc,
72 sizeof(*state->crtcs), GFP_KERNEL);
75 state->crtc_states = kcalloc(dev->mode_config.num_crtc,
76 sizeof(*state->crtc_states), GFP_KERNEL);
77 if (!state->crtc_states)
79 state->planes = kcalloc(dev->mode_config.num_total_plane,
80 sizeof(*state->planes), GFP_KERNEL);
83 state->plane_states = kcalloc(dev->mode_config.num_total_plane,
84 sizeof(*state->plane_states), GFP_KERNEL);
85 if (!state->plane_states)
90 DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state);
94 drm_atomic_state_default_release(state);
97 EXPORT_SYMBOL(drm_atomic_state_init);
100 * drm_atomic_state_alloc - allocate atomic state
103 * This allocates an empty atomic state to track updates.
105 struct drm_atomic_state *
106 drm_atomic_state_alloc(struct drm_device *dev)
108 struct drm_mode_config *config = &dev->mode_config;
109 struct drm_atomic_state *state;
111 if (!config->funcs->atomic_state_alloc) {
112 state = kzalloc(sizeof(*state), GFP_KERNEL);
115 if (drm_atomic_state_init(dev, state) < 0) {
122 return config->funcs->atomic_state_alloc(dev);
124 EXPORT_SYMBOL(drm_atomic_state_alloc);
127 * drm_atomic_state_default_clear - clear base atomic state
128 * @state: atomic state
130 * Default implementation for clearing atomic state.
131 * This is useful for drivers that subclass the atomic state.
133 void drm_atomic_state_default_clear(struct drm_atomic_state *state)
135 struct drm_device *dev = state->dev;
136 struct drm_mode_config *config = &dev->mode_config;
139 DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state);
141 for (i = 0; i < state->num_connector; i++) {
142 struct drm_connector *connector = state->connectors[i];
147 connector->funcs->atomic_destroy_state(connector,
148 state->connector_states[i]);
149 state->connectors[i] = NULL;
150 state->connector_states[i] = NULL;
151 drm_connector_unreference(connector);
154 for (i = 0; i < config->num_crtc; i++) {
155 struct drm_crtc *crtc = state->crtcs[i];
160 crtc->funcs->atomic_destroy_state(crtc,
161 state->crtc_states[i]);
162 state->crtcs[i] = NULL;
163 state->crtc_states[i] = NULL;
166 for (i = 0; i < config->num_total_plane; i++) {
167 struct drm_plane *plane = state->planes[i];
172 plane->funcs->atomic_destroy_state(plane,
173 state->plane_states[i]);
174 state->planes[i] = NULL;
175 state->plane_states[i] = NULL;
178 EXPORT_SYMBOL(drm_atomic_state_default_clear);
181 * drm_atomic_state_clear - clear state object
182 * @state: atomic state
184 * When the w/w mutex algorithm detects a deadlock we need to back off and drop
185 * all locks. So someone else could sneak in and change the current modeset
186 * configuration. Which means that all the state assembled in @state is no
187 * longer an atomic update to the current state, but to some arbitrary earlier
188 * state. Which could break assumptions the driver's ->atomic_check likely
191 * Hence we must clear all cached state and completely start over, using this
194 void drm_atomic_state_clear(struct drm_atomic_state *state)
196 struct drm_device *dev = state->dev;
197 struct drm_mode_config *config = &dev->mode_config;
199 if (config->funcs->atomic_state_clear)
200 config->funcs->atomic_state_clear(state);
202 drm_atomic_state_default_clear(state);
204 EXPORT_SYMBOL(drm_atomic_state_clear);
207 * drm_atomic_state_free - free all memory for an atomic state
208 * @state: atomic state to deallocate
210 * This frees all memory associated with an atomic state, including all the
211 * per-object state for planes, crtcs and connectors.
213 void drm_atomic_state_free(struct drm_atomic_state *state)
215 struct drm_device *dev;
216 struct drm_mode_config *config;
222 config = &dev->mode_config;
224 drm_atomic_state_clear(state);
226 DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state);
228 if (config->funcs->atomic_state_free) {
229 config->funcs->atomic_state_free(state);
231 drm_atomic_state_default_release(state);
235 EXPORT_SYMBOL(drm_atomic_state_free);
238 * drm_atomic_get_crtc_state - get crtc state
239 * @state: global atomic state object
240 * @crtc: crtc to get state object for
242 * This function returns the crtc state for the given crtc, allocating it if
243 * needed. It will also grab the relevant crtc lock to make sure that the state
248 * Either the allocated state or the error code encoded into the pointer. When
249 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
250 * entire atomic sequence must be restarted. All other errors are fatal.
252 struct drm_crtc_state *
253 drm_atomic_get_crtc_state(struct drm_atomic_state *state,
254 struct drm_crtc *crtc)
256 int ret, index = drm_crtc_index(crtc);
257 struct drm_crtc_state *crtc_state;
259 WARN_ON(!state->acquire_ctx);
261 crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
265 ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
269 crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
271 return ERR_PTR(-ENOMEM);
273 state->crtc_states[index] = crtc_state;
274 state->crtcs[index] = crtc;
275 crtc_state->state = state;
277 DRM_DEBUG_ATOMIC("Added [CRTC:%d:%s] %p state to %p\n",
278 crtc->base.id, crtc->name, crtc_state, state);
282 EXPORT_SYMBOL(drm_atomic_get_crtc_state);
285 * drm_atomic_set_mode_for_crtc - set mode for CRTC
286 * @state: the CRTC whose incoming state to update
287 * @mode: kernel-internal mode to use for the CRTC, or NULL to disable
289 * Set a mode (originating from the kernel) on the desired CRTC state. Does
290 * not change any other state properties, including enable, active, or
294 * Zero on success, error code on failure. Cannot return -EDEADLK.
296 int drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,
297 struct drm_display_mode *mode)
299 struct drm_mode_modeinfo umode;
301 /* Early return for no change. */
302 if (mode && memcmp(&state->mode, mode, sizeof(*mode)) == 0)
305 drm_property_unreference_blob(state->mode_blob);
306 state->mode_blob = NULL;
309 drm_mode_convert_to_umode(&umode, mode);
311 drm_property_create_blob(state->crtc->dev,
314 if (IS_ERR(state->mode_blob))
315 return PTR_ERR(state->mode_blob);
317 drm_mode_copy(&state->mode, mode);
318 state->enable = true;
319 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
322 memset(&state->mode, 0, sizeof(state->mode));
323 state->enable = false;
324 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
330 EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc);
333 * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC
334 * @state: the CRTC whose incoming state to update
335 * @blob: pointer to blob property to use for mode
337 * Set a mode (originating from a blob property) on the desired CRTC state.
338 * This function will take a reference on the blob property for the CRTC state,
339 * and release the reference held on the state's existing mode property, if any
343 * Zero on success, error code on failure. Cannot return -EDEADLK.
345 int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,
346 struct drm_property_blob *blob)
348 if (blob == state->mode_blob)
351 drm_property_unreference_blob(state->mode_blob);
352 state->mode_blob = NULL;
355 if (blob->length != sizeof(struct drm_mode_modeinfo) ||
356 drm_mode_convert_umode(&state->mode,
357 (const struct drm_mode_modeinfo *)
361 state->mode_blob = drm_property_reference_blob(blob);
362 state->enable = true;
363 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
364 state->mode.name, state);
366 memset(&state->mode, 0, sizeof(state->mode));
367 state->enable = false;
368 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
374 EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc);
377 * drm_atomic_replace_property_blob - replace a blob property
378 * @blob: a pointer to the member blob to be replaced
379 * @new_blob: the new blob to replace with
380 * @replaced: whether the blob has been replaced
383 * Zero on success, error code on failure
386 drm_atomic_replace_property_blob(struct drm_property_blob **blob,
387 struct drm_property_blob *new_blob,
390 struct drm_property_blob *old_blob = *blob;
392 if (old_blob == new_blob)
396 drm_property_unreference_blob(old_blob);
398 drm_property_reference_blob(new_blob);
406 drm_atomic_replace_property_blob_from_id(struct drm_crtc *crtc,
407 struct drm_property_blob **blob,
409 ssize_t expected_size,
412 struct drm_device *dev = crtc->dev;
413 struct drm_property_blob *new_blob = NULL;
416 new_blob = drm_property_lookup_blob(dev, blob_id);
417 if (new_blob == NULL)
419 if (expected_size > 0 && expected_size != new_blob->length)
423 drm_atomic_replace_property_blob(blob, new_blob, replaced);
429 * drm_atomic_crtc_set_property - set property on CRTC
430 * @crtc: the drm CRTC to set a property on
431 * @state: the state object to update with the new property value
432 * @property: the property to set
433 * @val: the new property value
435 * Use this instead of calling crtc->atomic_set_property directly.
436 * This function handles generic/core properties and calls out to
437 * driver's ->atomic_set_property() for driver properties. To ensure
438 * consistent behavior you must call this function rather than the
439 * driver hook directly.
442 * Zero on success, error code on failure
444 int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
445 struct drm_crtc_state *state, struct drm_property *property,
448 struct drm_device *dev = crtc->dev;
449 struct drm_mode_config *config = &dev->mode_config;
450 bool replaced = false;
453 if (property == config->prop_active)
455 else if (property == config->prop_mode_id) {
456 struct drm_property_blob *mode =
457 drm_property_lookup_blob(dev, val);
458 ret = drm_atomic_set_mode_prop_for_crtc(state, mode);
459 drm_property_unreference_blob(mode);
461 } else if (property == config->degamma_lut_property) {
462 ret = drm_atomic_replace_property_blob_from_id(crtc,
467 state->color_mgmt_changed = replaced;
469 } else if (property == config->ctm_property) {
470 ret = drm_atomic_replace_property_blob_from_id(crtc,
473 sizeof(struct drm_color_ctm),
475 state->color_mgmt_changed = replaced;
477 } else if (property == config->gamma_lut_property) {
478 ret = drm_atomic_replace_property_blob_from_id(crtc,
483 state->color_mgmt_changed = replaced;
485 } else if (crtc->funcs->atomic_set_property)
486 return crtc->funcs->atomic_set_property(crtc, state, property, val);
492 EXPORT_SYMBOL(drm_atomic_crtc_set_property);
495 * drm_atomic_crtc_get_property - get property value from CRTC state
496 * @crtc: the drm CRTC to set a property on
497 * @state: the state object to get the property value from
498 * @property: the property to set
499 * @val: return location for the property value
501 * This function handles generic/core properties and calls out to
502 * driver's ->atomic_get_property() for driver properties. To ensure
503 * consistent behavior you must call this function rather than the
504 * driver hook directly.
507 * Zero on success, error code on failure
510 drm_atomic_crtc_get_property(struct drm_crtc *crtc,
511 const struct drm_crtc_state *state,
512 struct drm_property *property, uint64_t *val)
514 struct drm_device *dev = crtc->dev;
515 struct drm_mode_config *config = &dev->mode_config;
517 if (property == config->prop_active)
518 *val = state->active;
519 else if (property == config->prop_mode_id)
520 *val = (state->mode_blob) ? state->mode_blob->base.id : 0;
521 else if (property == config->degamma_lut_property)
522 *val = (state->degamma_lut) ? state->degamma_lut->base.id : 0;
523 else if (property == config->ctm_property)
524 *val = (state->ctm) ? state->ctm->base.id : 0;
525 else if (property == config->gamma_lut_property)
526 *val = (state->gamma_lut) ? state->gamma_lut->base.id : 0;
527 else if (crtc->funcs->atomic_get_property)
528 return crtc->funcs->atomic_get_property(crtc, state, property, val);
536 * drm_atomic_crtc_check - check crtc state
537 * @crtc: crtc to check
538 * @state: crtc state to check
540 * Provides core sanity checks for crtc state.
543 * Zero on success, error code on failure
545 static int drm_atomic_crtc_check(struct drm_crtc *crtc,
546 struct drm_crtc_state *state)
548 /* NOTE: we explicitly don't enforce constraints such as primary
549 * layer covering entire screen, since that is something we want
550 * to allow (on hw that supports it). For hw that does not, it
551 * should be checked in driver's crtc->atomic_check() vfunc.
553 * TODO: Add generic modeset state checks once we support those.
556 if (state->active && !state->enable) {
557 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active without enabled\n",
558 crtc->base.id, crtc->name);
562 /* The state->enable vs. state->mode_blob checks can be WARN_ON,
563 * as this is a kernel-internal detail that userspace should never
564 * be able to trigger. */
565 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
566 WARN_ON(state->enable && !state->mode_blob)) {
567 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled without mode blob\n",
568 crtc->base.id, crtc->name);
572 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
573 WARN_ON(!state->enable && state->mode_blob)) {
574 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled with mode blob\n",
575 crtc->base.id, crtc->name);
580 * Reject event generation for when a CRTC is off and stays off.
581 * It wouldn't be hard to implement this, but userspace has a track
582 * record of happily burning through 100% cpu (or worse, crash) when the
583 * display pipe is suspended. To avoid all that fun just reject updates
584 * that ask for events since likely that indicates a bug in the
585 * compositor's drawing loop. This is consistent with the vblank IOCTL
586 * and legacy page_flip IOCTL which also reject service on a disabled
589 if (state->event && !state->active && !crtc->state->active) {
590 DRM_DEBUG_ATOMIC("[CRTC:%d] requesting event but off\n",
599 * drm_atomic_get_plane_state - get plane state
600 * @state: global atomic state object
601 * @plane: plane to get state object for
603 * This function returns the plane state for the given plane, allocating it if
604 * needed. It will also grab the relevant plane lock to make sure that the state
609 * Either the allocated state or the error code encoded into the pointer. When
610 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
611 * entire atomic sequence must be restarted. All other errors are fatal.
613 struct drm_plane_state *
614 drm_atomic_get_plane_state(struct drm_atomic_state *state,
615 struct drm_plane *plane)
617 int ret, index = drm_plane_index(plane);
618 struct drm_plane_state *plane_state;
620 WARN_ON(!state->acquire_ctx);
622 plane_state = drm_atomic_get_existing_plane_state(state, plane);
626 ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx);
630 plane_state = plane->funcs->atomic_duplicate_state(plane);
632 return ERR_PTR(-ENOMEM);
634 state->plane_states[index] = plane_state;
635 state->planes[index] = plane;
636 plane_state->state = state;
638 DRM_DEBUG_ATOMIC("Added [PLANE:%d:%s] %p state to %p\n",
639 plane->base.id, plane->name, plane_state, state);
641 if (plane_state->crtc) {
642 struct drm_crtc_state *crtc_state;
644 crtc_state = drm_atomic_get_crtc_state(state,
646 if (IS_ERR(crtc_state))
647 return ERR_CAST(crtc_state);
652 EXPORT_SYMBOL(drm_atomic_get_plane_state);
655 * drm_atomic_plane_set_property - set property on plane
656 * @plane: the drm plane to set a property on
657 * @state: the state object to update with the new property value
658 * @property: the property to set
659 * @val: the new property value
661 * Use this instead of calling plane->atomic_set_property directly.
662 * This function handles generic/core properties and calls out to
663 * driver's ->atomic_set_property() for driver properties. To ensure
664 * consistent behavior you must call this function rather than the
665 * driver hook directly.
668 * Zero on success, error code on failure
670 int drm_atomic_plane_set_property(struct drm_plane *plane,
671 struct drm_plane_state *state, struct drm_property *property,
674 struct drm_device *dev = plane->dev;
675 struct drm_mode_config *config = &dev->mode_config;
677 if (property == config->prop_fb_id) {
678 struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, val);
679 drm_atomic_set_fb_for_plane(state, fb);
681 drm_framebuffer_unreference(fb);
682 } else if (property == config->prop_crtc_id) {
683 struct drm_crtc *crtc = drm_crtc_find(dev, val);
684 return drm_atomic_set_crtc_for_plane(state, crtc);
685 } else if (property == config->prop_crtc_x) {
686 state->crtc_x = U642I64(val);
687 } else if (property == config->prop_crtc_y) {
688 state->crtc_y = U642I64(val);
689 } else if (property == config->prop_crtc_w) {
691 } else if (property == config->prop_crtc_h) {
693 } else if (property == config->prop_src_x) {
695 } else if (property == config->prop_src_y) {
697 } else if (property == config->prop_src_w) {
699 } else if (property == config->prop_src_h) {
701 } else if (property == config->rotation_property) {
702 state->rotation = val;
703 } else if (plane->funcs->atomic_set_property) {
704 return plane->funcs->atomic_set_property(plane, state,
712 EXPORT_SYMBOL(drm_atomic_plane_set_property);
715 * drm_atomic_plane_get_property - get property value from plane state
716 * @plane: the drm plane to set a property on
717 * @state: the state object to get the property value from
718 * @property: the property to set
719 * @val: return location for the property value
721 * This function handles generic/core properties and calls out to
722 * driver's ->atomic_get_property() for driver properties. To ensure
723 * consistent behavior you must call this function rather than the
724 * driver hook directly.
727 * Zero on success, error code on failure
730 drm_atomic_plane_get_property(struct drm_plane *plane,
731 const struct drm_plane_state *state,
732 struct drm_property *property, uint64_t *val)
734 struct drm_device *dev = plane->dev;
735 struct drm_mode_config *config = &dev->mode_config;
737 if (property == config->prop_fb_id) {
738 *val = (state->fb) ? state->fb->base.id : 0;
739 } else if (property == config->prop_crtc_id) {
740 *val = (state->crtc) ? state->crtc->base.id : 0;
741 } else if (property == config->prop_crtc_x) {
742 *val = I642U64(state->crtc_x);
743 } else if (property == config->prop_crtc_y) {
744 *val = I642U64(state->crtc_y);
745 } else if (property == config->prop_crtc_w) {
746 *val = state->crtc_w;
747 } else if (property == config->prop_crtc_h) {
748 *val = state->crtc_h;
749 } else if (property == config->prop_src_x) {
751 } else if (property == config->prop_src_y) {
753 } else if (property == config->prop_src_w) {
755 } else if (property == config->prop_src_h) {
757 } else if (property == config->rotation_property) {
758 *val = state->rotation;
759 } else if (plane->funcs->atomic_get_property) {
760 return plane->funcs->atomic_get_property(plane, state, property, val);
769 plane_switching_crtc(struct drm_atomic_state *state,
770 struct drm_plane *plane,
771 struct drm_plane_state *plane_state)
773 if (!plane->state->crtc || !plane_state->crtc)
776 if (plane->state->crtc == plane_state->crtc)
779 /* This could be refined, but currently there's no helper or driver code
780 * to implement direct switching of active planes nor userspace to take
781 * advantage of more direct plane switching without the intermediate
788 * drm_atomic_plane_check - check plane state
789 * @plane: plane to check
790 * @state: plane state to check
792 * Provides core sanity checks for plane state.
795 * Zero on success, error code on failure
797 static int drm_atomic_plane_check(struct drm_plane *plane,
798 struct drm_plane_state *state)
800 unsigned int fb_width, fb_height;
803 /* either *both* CRTC and FB must be set, or neither */
804 if (WARN_ON(state->crtc && !state->fb)) {
805 DRM_DEBUG_ATOMIC("CRTC set but no FB\n");
807 } else if (WARN_ON(state->fb && !state->crtc)) {
808 DRM_DEBUG_ATOMIC("FB set but no CRTC\n");
812 /* if disabled, we don't care about the rest of the state: */
816 /* Check whether this plane is usable on this CRTC */
817 if (!(plane->possible_crtcs & drm_crtc_mask(state->crtc))) {
818 DRM_DEBUG_ATOMIC("Invalid crtc for plane\n");
822 /* Check whether this plane supports the fb pixel format. */
823 ret = drm_plane_check_pixel_format(plane, state->fb->pixel_format);
825 DRM_DEBUG_ATOMIC("Invalid pixel format %s\n",
826 drm_get_format_name(state->fb->pixel_format));
830 /* Give drivers some help against integer overflows */
831 if (state->crtc_w > INT_MAX ||
832 state->crtc_x > INT_MAX - (int32_t) state->crtc_w ||
833 state->crtc_h > INT_MAX ||
834 state->crtc_y > INT_MAX - (int32_t) state->crtc_h) {
835 DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n",
836 state->crtc_w, state->crtc_h,
837 state->crtc_x, state->crtc_y);
841 fb_width = state->fb->width << 16;
842 fb_height = state->fb->height << 16;
844 /* Make sure source coordinates are inside the fb. */
845 if (state->src_w > fb_width ||
846 state->src_x > fb_width - state->src_w ||
847 state->src_h > fb_height ||
848 state->src_y > fb_height - state->src_h) {
849 DRM_DEBUG_ATOMIC("Invalid source coordinates "
850 "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
851 state->src_w >> 16, ((state->src_w & 0xffff) * 15625) >> 10,
852 state->src_h >> 16, ((state->src_h & 0xffff) * 15625) >> 10,
853 state->src_x >> 16, ((state->src_x & 0xffff) * 15625) >> 10,
854 state->src_y >> 16, ((state->src_y & 0xffff) * 15625) >> 10);
858 if (plane_switching_crtc(state->state, plane, state)) {
859 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] switching CRTC directly\n",
860 plane->base.id, plane->name);
868 * drm_atomic_get_connector_state - get connector state
869 * @state: global atomic state object
870 * @connector: connector to get state object for
872 * This function returns the connector state for the given connector,
873 * allocating it if needed. It will also grab the relevant connector lock to
874 * make sure that the state is consistent.
878 * Either the allocated state or the error code encoded into the pointer. When
879 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
880 * entire atomic sequence must be restarted. All other errors are fatal.
882 struct drm_connector_state *
883 drm_atomic_get_connector_state(struct drm_atomic_state *state,
884 struct drm_connector *connector)
887 struct drm_mode_config *config = &connector->dev->mode_config;
888 struct drm_connector_state *connector_state;
890 WARN_ON(!state->acquire_ctx);
892 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
896 index = drm_connector_index(connector);
898 if (index >= state->num_connector) {
899 struct drm_connector **c;
900 struct drm_connector_state **cs;
901 int alloc = max(index + 1, config->num_connector);
903 c = krealloc(state->connectors, alloc * sizeof(*state->connectors), GFP_KERNEL);
905 return ERR_PTR(-ENOMEM);
907 state->connectors = c;
908 memset(&state->connectors[state->num_connector], 0,
909 sizeof(*state->connectors) * (alloc - state->num_connector));
911 cs = krealloc(state->connector_states, alloc * sizeof(*state->connector_states), GFP_KERNEL);
913 return ERR_PTR(-ENOMEM);
915 state->connector_states = cs;
916 memset(&state->connector_states[state->num_connector], 0,
917 sizeof(*state->connector_states) * (alloc - state->num_connector));
918 state->num_connector = alloc;
921 if (state->connector_states[index])
922 return state->connector_states[index];
924 connector_state = connector->funcs->atomic_duplicate_state(connector);
925 if (!connector_state)
926 return ERR_PTR(-ENOMEM);
928 drm_connector_reference(connector);
929 state->connector_states[index] = connector_state;
930 state->connectors[index] = connector;
931 connector_state->state = state;
933 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d] %p state to %p\n",
934 connector->base.id, connector_state, state);
936 if (connector_state->crtc) {
937 struct drm_crtc_state *crtc_state;
939 crtc_state = drm_atomic_get_crtc_state(state,
940 connector_state->crtc);
941 if (IS_ERR(crtc_state))
942 return ERR_CAST(crtc_state);
945 return connector_state;
947 EXPORT_SYMBOL(drm_atomic_get_connector_state);
950 * drm_atomic_connector_set_property - set property on connector.
951 * @connector: the drm connector to set a property on
952 * @state: the state object to update with the new property value
953 * @property: the property to set
954 * @val: the new property value
956 * Use this instead of calling connector->atomic_set_property directly.
957 * This function handles generic/core properties and calls out to
958 * driver's ->atomic_set_property() for driver properties. To ensure
959 * consistent behavior you must call this function rather than the
960 * driver hook directly.
963 * Zero on success, error code on failure
965 int drm_atomic_connector_set_property(struct drm_connector *connector,
966 struct drm_connector_state *state, struct drm_property *property,
969 struct drm_device *dev = connector->dev;
970 struct drm_mode_config *config = &dev->mode_config;
972 if (property == config->prop_crtc_id) {
973 struct drm_crtc *crtc = drm_crtc_find(dev, val);
974 return drm_atomic_set_crtc_for_connector(state, crtc);
975 } else if (property == config->dpms_property) {
976 /* setting DPMS property requires special handling, which
977 * is done in legacy setprop path for us. Disallow (for
978 * now?) atomic writes to DPMS property:
981 } else if (connector->funcs->atomic_set_property) {
982 return connector->funcs->atomic_set_property(connector,
983 state, property, val);
988 EXPORT_SYMBOL(drm_atomic_connector_set_property);
991 * drm_atomic_connector_get_property - get property value from connector state
992 * @connector: the drm connector to set a property on
993 * @state: the state object to get the property value from
994 * @property: the property to set
995 * @val: return location for the property value
997 * This function handles generic/core properties and calls out to
998 * driver's ->atomic_get_property() for driver properties. To ensure
999 * consistent behavior you must call this function rather than the
1000 * driver hook directly.
1003 * Zero on success, error code on failure
1006 drm_atomic_connector_get_property(struct drm_connector *connector,
1007 const struct drm_connector_state *state,
1008 struct drm_property *property, uint64_t *val)
1010 struct drm_device *dev = connector->dev;
1011 struct drm_mode_config *config = &dev->mode_config;
1013 if (property == config->prop_crtc_id) {
1014 *val = (state->crtc) ? state->crtc->base.id : 0;
1015 } else if (property == config->dpms_property) {
1016 *val = connector->dpms;
1017 } else if (connector->funcs->atomic_get_property) {
1018 return connector->funcs->atomic_get_property(connector,
1019 state, property, val);
1027 int drm_atomic_get_property(struct drm_mode_object *obj,
1028 struct drm_property *property, uint64_t *val)
1030 struct drm_device *dev = property->dev;
1033 switch (obj->type) {
1034 case DRM_MODE_OBJECT_CONNECTOR: {
1035 struct drm_connector *connector = obj_to_connector(obj);
1036 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
1037 ret = drm_atomic_connector_get_property(connector,
1038 connector->state, property, val);
1041 case DRM_MODE_OBJECT_CRTC: {
1042 struct drm_crtc *crtc = obj_to_crtc(obj);
1043 WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
1044 ret = drm_atomic_crtc_get_property(crtc,
1045 crtc->state, property, val);
1048 case DRM_MODE_OBJECT_PLANE: {
1049 struct drm_plane *plane = obj_to_plane(obj);
1050 WARN_ON(!drm_modeset_is_locked(&plane->mutex));
1051 ret = drm_atomic_plane_get_property(plane,
1052 plane->state, property, val);
1064 * drm_atomic_set_crtc_for_plane - set crtc for plane
1065 * @plane_state: the plane whose incoming state to update
1066 * @crtc: crtc to use for the plane
1068 * Changing the assigned crtc for a plane requires us to grab the lock and state
1069 * for the new crtc, as needed. This function takes care of all these details
1070 * besides updating the pointer in the state object itself.
1073 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1074 * then the w/w mutex code has detected a deadlock and the entire atomic
1075 * sequence must be restarted. All other errors are fatal.
1078 drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
1079 struct drm_crtc *crtc)
1081 struct drm_plane *plane = plane_state->plane;
1082 struct drm_crtc_state *crtc_state;
1084 if (plane_state->crtc) {
1085 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
1087 if (WARN_ON(IS_ERR(crtc_state)))
1088 return PTR_ERR(crtc_state);
1090 crtc_state->plane_mask &= ~(1 << drm_plane_index(plane));
1093 plane_state->crtc = crtc;
1096 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
1098 if (IS_ERR(crtc_state))
1099 return PTR_ERR(crtc_state);
1100 crtc_state->plane_mask |= (1 << drm_plane_index(plane));
1104 DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d:%s]\n",
1105 plane_state, crtc->base.id, crtc->name);
1107 DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n",
1112 EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane);
1115 * drm_atomic_set_fb_for_plane - set framebuffer for plane
1116 * @plane_state: atomic state object for the plane
1117 * @fb: fb to use for the plane
1119 * Changing the assigned framebuffer for a plane requires us to grab a reference
1120 * to the new fb and drop the reference to the old fb, if there is one. This
1121 * function takes care of all these details besides updating the pointer in the
1122 * state object itself.
1125 drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
1126 struct drm_framebuffer *fb)
1128 if (plane_state->fb)
1129 drm_framebuffer_unreference(plane_state->fb);
1131 drm_framebuffer_reference(fb);
1132 plane_state->fb = fb;
1135 DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n",
1136 fb->base.id, plane_state);
1138 DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n",
1141 EXPORT_SYMBOL(drm_atomic_set_fb_for_plane);
1144 * drm_atomic_set_crtc_for_connector - set crtc for connector
1145 * @conn_state: atomic state object for the connector
1146 * @crtc: crtc to use for the connector
1148 * Changing the assigned crtc for a connector requires us to grab the lock and
1149 * state for the new crtc, as needed. This function takes care of all these
1150 * details besides updating the pointer in the state object itself.
1153 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1154 * then the w/w mutex code has detected a deadlock and the entire atomic
1155 * sequence must be restarted. All other errors are fatal.
1158 drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
1159 struct drm_crtc *crtc)
1161 struct drm_crtc_state *crtc_state;
1164 drm_connector_reference(conn_state->connector);
1165 if (conn_state->crtc && conn_state->crtc != crtc) {
1166 crtc_state = drm_atomic_get_existing_crtc_state(conn_state->state,
1169 crtc_state->connector_mask &=
1170 ~(1 << drm_connector_index(conn_state->connector));
1174 crtc_state = drm_atomic_get_crtc_state(conn_state->state, crtc);
1175 if (IS_ERR(crtc_state))
1176 return PTR_ERR(crtc_state);
1178 crtc_state->connector_mask |=
1179 1 << drm_connector_index(conn_state->connector);
1182 if (conn_state->crtc)
1183 drm_connector_unreference(conn_state->connector);
1184 conn_state->crtc = crtc;
1187 DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d:%s]\n",
1188 conn_state, crtc->base.id, crtc->name);
1190 DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n",
1195 EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector);
1198 * drm_atomic_add_affected_connectors - add connectors for crtc
1199 * @state: atomic state
1202 * This function walks the current configuration and adds all connectors
1203 * currently using @crtc to the atomic configuration @state. Note that this
1204 * function must acquire the connection mutex. This can potentially cause
1205 * unneeded seralization if the update is just for the planes on one crtc. Hence
1206 * drivers and helpers should only call this when really needed (e.g. when a
1207 * full modeset needs to happen due to some change).
1210 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1211 * then the w/w mutex code has detected a deadlock and the entire atomic
1212 * sequence must be restarted. All other errors are fatal.
1215 drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
1216 struct drm_crtc *crtc)
1218 struct drm_mode_config *config = &state->dev->mode_config;
1219 struct drm_connector *connector;
1220 struct drm_connector_state *conn_state;
1223 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
1227 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %p\n",
1228 crtc->base.id, crtc->name, state);
1231 * Changed connectors are already in @state, so only need to look at the
1232 * current configuration.
1234 drm_for_each_connector(connector, state->dev) {
1235 if (connector->state->crtc != crtc)
1238 conn_state = drm_atomic_get_connector_state(state, connector);
1239 if (IS_ERR(conn_state))
1240 return PTR_ERR(conn_state);
1245 EXPORT_SYMBOL(drm_atomic_add_affected_connectors);
1248 * drm_atomic_add_affected_planes - add planes for crtc
1249 * @state: atomic state
1252 * This function walks the current configuration and adds all planes
1253 * currently used by @crtc to the atomic configuration @state. This is useful
1254 * when an atomic commit also needs to check all currently enabled plane on
1255 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1256 * to avoid special code to force-enable all planes.
1258 * Since acquiring a plane state will always also acquire the w/w mutex of the
1259 * current CRTC for that plane (if there is any) adding all the plane states for
1260 * a CRTC will not reduce parallism of atomic updates.
1263 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1264 * then the w/w mutex code has detected a deadlock and the entire atomic
1265 * sequence must be restarted. All other errors are fatal.
1268 drm_atomic_add_affected_planes(struct drm_atomic_state *state,
1269 struct drm_crtc *crtc)
1271 struct drm_plane *plane;
1273 WARN_ON(!drm_atomic_get_existing_crtc_state(state, crtc));
1275 drm_for_each_plane_mask(plane, state->dev, crtc->state->plane_mask) {
1276 struct drm_plane_state *plane_state =
1277 drm_atomic_get_plane_state(state, plane);
1279 if (IS_ERR(plane_state))
1280 return PTR_ERR(plane_state);
1284 EXPORT_SYMBOL(drm_atomic_add_affected_planes);
1287 * drm_atomic_legacy_backoff - locking backoff for legacy ioctls
1288 * @state: atomic state
1290 * This function should be used by legacy entry points which don't understand
1291 * -EDEADLK semantics. For simplicity this one will grab all modeset locks after
1292 * the slowpath completed.
1294 void drm_atomic_legacy_backoff(struct drm_atomic_state *state)
1299 drm_modeset_backoff(state->acquire_ctx);
1301 ret = drm_modeset_lock_all_ctx(state->dev, state->acquire_ctx);
1305 EXPORT_SYMBOL(drm_atomic_legacy_backoff);
1308 * drm_atomic_check_only - check whether a given config would work
1309 * @state: atomic configuration to check
1311 * Note that this function can return -EDEADLK if the driver needed to acquire
1312 * more locks but encountered a deadlock. The caller must then do the usual w/w
1313 * backoff dance and restart. All other errors are fatal.
1316 * 0 on success, negative error code on failure.
1318 int drm_atomic_check_only(struct drm_atomic_state *state)
1320 struct drm_device *dev = state->dev;
1321 struct drm_mode_config *config = &dev->mode_config;
1322 struct drm_plane *plane;
1323 struct drm_plane_state *plane_state;
1324 struct drm_crtc *crtc;
1325 struct drm_crtc_state *crtc_state;
1328 DRM_DEBUG_ATOMIC("checking %p\n", state);
1330 for_each_plane_in_state(state, plane, plane_state, i) {
1331 ret = drm_atomic_plane_check(plane, plane_state);
1333 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic core check failed\n",
1334 plane->base.id, plane->name);
1339 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1340 ret = drm_atomic_crtc_check(crtc, crtc_state);
1342 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic core check failed\n",
1343 crtc->base.id, crtc->name);
1348 if (config->funcs->atomic_check)
1349 ret = config->funcs->atomic_check(state->dev, state);
1351 if (!state->allow_modeset) {
1352 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1353 if (drm_atomic_crtc_needs_modeset(crtc_state)) {
1354 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requires full modeset\n",
1355 crtc->base.id, crtc->name);
1363 EXPORT_SYMBOL(drm_atomic_check_only);
1366 * drm_atomic_commit - commit configuration atomically
1367 * @state: atomic configuration to check
1369 * Note that this function can return -EDEADLK if the driver needed to acquire
1370 * more locks but encountered a deadlock. The caller must then do the usual w/w
1371 * backoff dance and restart. All other errors are fatal.
1373 * Also note that on successful execution ownership of @state is transferred
1374 * from the caller of this function to the function itself. The caller must not
1375 * free or in any other way access @state. If the function fails then the caller
1376 * must clean up @state itself.
1379 * 0 on success, negative error code on failure.
1381 int drm_atomic_commit(struct drm_atomic_state *state)
1383 struct drm_mode_config *config = &state->dev->mode_config;
1386 ret = drm_atomic_check_only(state);
1390 DRM_DEBUG_ATOMIC("commiting %p\n", state);
1392 return config->funcs->atomic_commit(state->dev, state, false);
1394 EXPORT_SYMBOL(drm_atomic_commit);
1397 * drm_atomic_nonblocking_commit - atomic&nonblocking configuration commit
1398 * @state: atomic configuration to check
1400 * Note that this function can return -EDEADLK if the driver needed to acquire
1401 * more locks but encountered a deadlock. The caller must then do the usual w/w
1402 * backoff dance and restart. All other errors are fatal.
1404 * Also note that on successful execution ownership of @state is transferred
1405 * from the caller of this function to the function itself. The caller must not
1406 * free or in any other way access @state. If the function fails then the caller
1407 * must clean up @state itself.
1410 * 0 on success, negative error code on failure.
1412 int drm_atomic_nonblocking_commit(struct drm_atomic_state *state)
1414 struct drm_mode_config *config = &state->dev->mode_config;
1417 ret = drm_atomic_check_only(state);
1421 DRM_DEBUG_ATOMIC("commiting %p nonblocking\n", state);
1423 return config->funcs->atomic_commit(state->dev, state, true);
1425 EXPORT_SYMBOL(drm_atomic_nonblocking_commit);
1428 * The big monstor ioctl
1431 static struct drm_pending_vblank_event *create_vblank_event(
1432 struct drm_device *dev, struct drm_file *file_priv, uint64_t user_data)
1434 struct drm_pending_vblank_event *e = NULL;
1437 e = kzalloc(sizeof *e, GFP_KERNEL);
1441 e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
1442 e->event.base.length = sizeof(e->event);
1443 e->event.user_data = user_data;
1445 ret = drm_event_reserve_init(dev, file_priv, &e->base, &e->event.base);
1454 static int atomic_set_prop(struct drm_atomic_state *state,
1455 struct drm_mode_object *obj, struct drm_property *prop,
1456 uint64_t prop_value)
1458 struct drm_mode_object *ref;
1461 if (!drm_property_change_valid_get(prop, prop_value, &ref))
1464 switch (obj->type) {
1465 case DRM_MODE_OBJECT_CONNECTOR: {
1466 struct drm_connector *connector = obj_to_connector(obj);
1467 struct drm_connector_state *connector_state;
1469 connector_state = drm_atomic_get_connector_state(state, connector);
1470 if (IS_ERR(connector_state)) {
1471 ret = PTR_ERR(connector_state);
1475 ret = drm_atomic_connector_set_property(connector,
1476 connector_state, prop, prop_value);
1479 case DRM_MODE_OBJECT_CRTC: {
1480 struct drm_crtc *crtc = obj_to_crtc(obj);
1481 struct drm_crtc_state *crtc_state;
1483 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1484 if (IS_ERR(crtc_state)) {
1485 ret = PTR_ERR(crtc_state);
1489 ret = drm_atomic_crtc_set_property(crtc,
1490 crtc_state, prop, prop_value);
1493 case DRM_MODE_OBJECT_PLANE: {
1494 struct drm_plane *plane = obj_to_plane(obj);
1495 struct drm_plane_state *plane_state;
1497 plane_state = drm_atomic_get_plane_state(state, plane);
1498 if (IS_ERR(plane_state)) {
1499 ret = PTR_ERR(plane_state);
1503 ret = drm_atomic_plane_set_property(plane,
1504 plane_state, prop, prop_value);
1512 drm_property_change_valid_put(prop, ref);
1517 * drm_atomic_clean_old_fb -- Unset old_fb pointers and set plane->fb pointers.
1519 * @dev: drm device to check.
1520 * @plane_mask: plane mask for planes that were updated.
1521 * @ret: return value, can be -EDEADLK for a retry.
1523 * Before doing an update plane->old_fb is set to plane->fb,
1524 * but before dropping the locks old_fb needs to be set to NULL
1525 * and plane->fb updated. This is a common operation for each
1526 * atomic update, so this call is split off as a helper.
1528 void drm_atomic_clean_old_fb(struct drm_device *dev,
1529 unsigned plane_mask,
1532 struct drm_plane *plane;
1534 /* if succeeded, fixup legacy plane crtc/fb ptrs before dropping
1535 * locks (ie. while it is still safe to deref plane->state). We
1536 * need to do this here because the driver entry points cannot
1537 * distinguish between legacy and atomic ioctls.
1539 drm_for_each_plane_mask(plane, dev, plane_mask) {
1541 struct drm_framebuffer *new_fb = plane->state->fb;
1543 drm_framebuffer_reference(new_fb);
1545 plane->crtc = plane->state->crtc;
1548 drm_framebuffer_unreference(plane->old_fb);
1550 plane->old_fb = NULL;
1553 EXPORT_SYMBOL(drm_atomic_clean_old_fb);
1555 int drm_mode_atomic_ioctl(struct drm_device *dev,
1556 void *data, struct drm_file *file_priv)
1558 struct drm_mode_atomic *arg = data;
1559 uint32_t __user *objs_ptr = (uint32_t __user *)(unsigned long)(arg->objs_ptr);
1560 uint32_t __user *count_props_ptr = (uint32_t __user *)(unsigned long)(arg->count_props_ptr);
1561 uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
1562 uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr);
1563 unsigned int copied_objs, copied_props;
1564 struct drm_atomic_state *state;
1565 struct drm_modeset_acquire_ctx ctx;
1566 struct drm_plane *plane;
1567 struct drm_crtc *crtc;
1568 struct drm_crtc_state *crtc_state;
1569 unsigned plane_mask;
1573 /* disallow for drivers not supporting atomic: */
1574 if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
1577 /* disallow for userspace that has not enabled atomic cap (even
1578 * though this may be a bit overkill, since legacy userspace
1579 * wouldn't know how to call this ioctl)
1581 if (!file_priv->atomic)
1584 if (arg->flags & ~DRM_MODE_ATOMIC_FLAGS)
1590 if ((arg->flags & DRM_MODE_PAGE_FLIP_ASYNC) &&
1591 !dev->mode_config.async_page_flip)
1594 /* can't test and expect an event at the same time. */
1595 if ((arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) &&
1596 (arg->flags & DRM_MODE_PAGE_FLIP_EVENT))
1599 drm_modeset_acquire_init(&ctx, 0);
1601 state = drm_atomic_state_alloc(dev);
1605 state->acquire_ctx = &ctx;
1606 state->allow_modeset = !!(arg->flags & DRM_MODE_ATOMIC_ALLOW_MODESET);
1613 for (i = 0; i < arg->count_objs; i++) {
1614 uint32_t obj_id, count_props;
1615 struct drm_mode_object *obj;
1617 if (get_user(obj_id, objs_ptr + copied_objs)) {
1622 obj = drm_mode_object_find(dev, obj_id, DRM_MODE_OBJECT_ANY);
1628 if (!obj->properties) {
1629 drm_mode_object_unreference(obj);
1634 if (get_user(count_props, count_props_ptr + copied_objs)) {
1635 drm_mode_object_unreference(obj);
1642 for (j = 0; j < count_props; j++) {
1644 uint64_t prop_value;
1645 struct drm_property *prop;
1647 if (get_user(prop_id, props_ptr + copied_props)) {
1648 drm_mode_object_unreference(obj);
1653 prop = drm_property_find(dev, prop_id);
1655 drm_mode_object_unreference(obj);
1660 if (copy_from_user(&prop_value,
1661 prop_values_ptr + copied_props,
1662 sizeof(prop_value))) {
1663 drm_mode_object_unreference(obj);
1668 ret = atomic_set_prop(state, obj, prop, prop_value);
1670 drm_mode_object_unreference(obj);
1677 if (obj->type == DRM_MODE_OBJECT_PLANE && count_props &&
1678 !(arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)) {
1679 plane = obj_to_plane(obj);
1680 plane_mask |= (1 << drm_plane_index(plane));
1681 plane->old_fb = plane->fb;
1683 drm_mode_object_unreference(obj);
1686 if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1687 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1688 struct drm_pending_vblank_event *e;
1690 e = create_vblank_event(dev, file_priv, arg->user_data);
1696 crtc_state->event = e;
1700 if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) {
1702 * Unlike commit, check_only does not clean up state.
1703 * Below we call drm_atomic_state_free for it.
1705 ret = drm_atomic_check_only(state);
1706 } else if (arg->flags & DRM_MODE_ATOMIC_NONBLOCK) {
1707 ret = drm_atomic_nonblocking_commit(state);
1709 ret = drm_atomic_commit(state);
1713 drm_atomic_clean_old_fb(dev, plane_mask, ret);
1715 if (ret && arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1717 * TEST_ONLY and PAGE_FLIP_EVENT are mutually exclusive,
1718 * if they weren't, this code should be called on success
1719 * for TEST_ONLY too.
1722 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1723 if (!crtc_state->event)
1726 drm_event_cancel_free(dev, &crtc_state->event->base);
1730 if (ret == -EDEADLK) {
1731 drm_atomic_state_clear(state);
1732 drm_modeset_backoff(&ctx);
1736 if (ret || arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)
1737 drm_atomic_state_free(state);
1739 drm_modeset_drop_locks(&ctx);
1740 drm_modeset_acquire_fini(&ctx);