2 * Copyright (C) 2014 Red Hat
3 * Copyright (C) 2014 Intel Corp.
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
24 * Rob Clark <robdclark@gmail.com>
25 * Daniel Vetter <daniel.vetter@ffwll.ch>
30 #include <drm/drm_atomic.h>
31 #include <drm/drm_plane_helper.h>
34 * drm_atomic_state_default_release -
35 * release memory initialized by drm_atomic_state_init
36 * @state: atomic state
38 * Free all the memory allocated by drm_atomic_state_init.
39 * This is useful for drivers that subclass the atomic state.
41 void drm_atomic_state_default_release(struct drm_atomic_state *state)
43 kfree(state->connectors);
44 kfree(state->connector_states);
46 kfree(state->crtc_states);
48 kfree(state->plane_states);
50 EXPORT_SYMBOL(drm_atomic_state_default_release);
53 * drm_atomic_state_init - init new atomic state
55 * @state: atomic state
57 * Default implementation for filling in a new atomic state.
58 * This is useful for drivers that subclass the atomic state.
61 drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state)
63 /* TODO legacy paths should maybe do a better job about
64 * setting this appropriately?
66 state->allow_modeset = true;
68 state->num_connector = ACCESS_ONCE(dev->mode_config.num_connector);
70 state->crtcs = kcalloc(dev->mode_config.num_crtc,
71 sizeof(*state->crtcs), GFP_KERNEL);
74 state->crtc_states = kcalloc(dev->mode_config.num_crtc,
75 sizeof(*state->crtc_states), GFP_KERNEL);
76 if (!state->crtc_states)
78 state->planes = kcalloc(dev->mode_config.num_total_plane,
79 sizeof(*state->planes), GFP_KERNEL);
82 state->plane_states = kcalloc(dev->mode_config.num_total_plane,
83 sizeof(*state->plane_states), GFP_KERNEL);
84 if (!state->plane_states)
86 state->connectors = kcalloc(state->num_connector,
87 sizeof(*state->connectors),
89 if (!state->connectors)
91 state->connector_states = kcalloc(state->num_connector,
92 sizeof(*state->connector_states),
94 if (!state->connector_states)
99 DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state);
103 drm_atomic_state_default_release(state);
106 EXPORT_SYMBOL(drm_atomic_state_init);
109 * drm_atomic_state_alloc - allocate atomic state
112 * This allocates an empty atomic state to track updates.
114 struct drm_atomic_state *
115 drm_atomic_state_alloc(struct drm_device *dev)
117 struct drm_mode_config *config = &dev->mode_config;
118 struct drm_atomic_state *state;
120 if (!config->funcs->atomic_state_alloc) {
121 state = kzalloc(sizeof(*state), GFP_KERNEL);
124 if (drm_atomic_state_init(dev, state) < 0) {
131 return config->funcs->atomic_state_alloc(dev);
133 EXPORT_SYMBOL(drm_atomic_state_alloc);
136 * drm_atomic_state_default_clear - clear base atomic state
137 * @state: atomic state
139 * Default implementation for clearing atomic state.
140 * This is useful for drivers that subclass the atomic state.
142 void drm_atomic_state_default_clear(struct drm_atomic_state *state)
144 struct drm_device *dev = state->dev;
145 struct drm_mode_config *config = &dev->mode_config;
148 DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state);
150 for (i = 0; i < state->num_connector; i++) {
151 struct drm_connector *connector = state->connectors[i];
157 * FIXME: Async commits can race with connector unplugging and
158 * there's currently nothing that prevents cleanup up state for
159 * deleted connectors. As long as the callback doesn't look at
160 * the connector we'll be fine though, so make sure that's the
161 * case by setting all connector pointers to NULL.
163 state->connector_states[i]->connector = NULL;
164 connector->funcs->atomic_destroy_state(NULL,
165 state->connector_states[i]);
166 state->connectors[i] = NULL;
167 state->connector_states[i] = NULL;
170 for (i = 0; i < config->num_crtc; i++) {
171 struct drm_crtc *crtc = state->crtcs[i];
176 crtc->funcs->atomic_destroy_state(crtc,
177 state->crtc_states[i]);
178 state->crtcs[i] = NULL;
179 state->crtc_states[i] = NULL;
182 for (i = 0; i < config->num_total_plane; i++) {
183 struct drm_plane *plane = state->planes[i];
188 plane->funcs->atomic_destroy_state(plane,
189 state->plane_states[i]);
190 state->planes[i] = NULL;
191 state->plane_states[i] = NULL;
194 EXPORT_SYMBOL(drm_atomic_state_default_clear);
197 * drm_atomic_state_clear - clear state object
198 * @state: atomic state
200 * When the w/w mutex algorithm detects a deadlock we need to back off and drop
201 * all locks. So someone else could sneak in and change the current modeset
202 * configuration. Which means that all the state assembled in @state is no
203 * longer an atomic update to the current state, but to some arbitrary earlier
204 * state. Which could break assumptions the driver's ->atomic_check likely
207 * Hence we must clear all cached state and completely start over, using this
210 void drm_atomic_state_clear(struct drm_atomic_state *state)
212 struct drm_device *dev = state->dev;
213 struct drm_mode_config *config = &dev->mode_config;
215 if (config->funcs->atomic_state_clear)
216 config->funcs->atomic_state_clear(state);
218 drm_atomic_state_default_clear(state);
220 EXPORT_SYMBOL(drm_atomic_state_clear);
223 * drm_atomic_state_free - free all memory for an atomic state
224 * @state: atomic state to deallocate
226 * This frees all memory associated with an atomic state, including all the
227 * per-object state for planes, crtcs and connectors.
229 void drm_atomic_state_free(struct drm_atomic_state *state)
231 struct drm_device *dev;
232 struct drm_mode_config *config;
238 config = &dev->mode_config;
240 drm_atomic_state_clear(state);
242 DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state);
244 if (config->funcs->atomic_state_free) {
245 config->funcs->atomic_state_free(state);
247 drm_atomic_state_default_release(state);
251 EXPORT_SYMBOL(drm_atomic_state_free);
254 * drm_atomic_get_crtc_state - get crtc state
255 * @state: global atomic state object
256 * @crtc: crtc to get state object for
258 * This function returns the crtc state for the given crtc, allocating it if
259 * needed. It will also grab the relevant crtc lock to make sure that the state
264 * Either the allocated state or the error code encoded into the pointer. When
265 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
266 * entire atomic sequence must be restarted. All other errors are fatal.
268 struct drm_crtc_state *
269 drm_atomic_get_crtc_state(struct drm_atomic_state *state,
270 struct drm_crtc *crtc)
272 int ret, index = drm_crtc_index(crtc);
273 struct drm_crtc_state *crtc_state;
275 crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
279 ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
283 crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
285 return ERR_PTR(-ENOMEM);
287 state->crtc_states[index] = crtc_state;
288 state->crtcs[index] = crtc;
289 crtc_state->state = state;
291 DRM_DEBUG_ATOMIC("Added [CRTC:%d] %p state to %p\n",
292 crtc->base.id, crtc_state, state);
296 EXPORT_SYMBOL(drm_atomic_get_crtc_state);
299 * drm_atomic_set_mode_for_crtc - set mode for CRTC
300 * @state: the CRTC whose incoming state to update
301 * @mode: kernel-internal mode to use for the CRTC, or NULL to disable
303 * Set a mode (originating from the kernel) on the desired CRTC state. Does
304 * not change any other state properties, including enable, active, or
308 * Zero on success, error code on failure. Cannot return -EDEADLK.
310 int drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,
311 struct drm_display_mode *mode)
313 struct drm_mode_modeinfo umode;
315 /* Early return for no change. */
316 if (mode && memcmp(&state->mode, mode, sizeof(*mode)) == 0)
319 if (state->mode_blob)
320 drm_property_unreference_blob(state->mode_blob);
321 state->mode_blob = NULL;
324 drm_mode_convert_to_umode(&umode, mode);
326 drm_property_create_blob(state->crtc->dev,
329 if (IS_ERR(state->mode_blob))
330 return PTR_ERR(state->mode_blob);
332 drm_mode_copy(&state->mode, mode);
333 state->enable = true;
334 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
337 memset(&state->mode, 0, sizeof(state->mode));
338 state->enable = false;
339 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
345 EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc);
348 * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC
349 * @state: the CRTC whose incoming state to update
350 * @blob: pointer to blob property to use for mode
352 * Set a mode (originating from a blob property) on the desired CRTC state.
353 * This function will take a reference on the blob property for the CRTC state,
354 * and release the reference held on the state's existing mode property, if any
358 * Zero on success, error code on failure. Cannot return -EDEADLK.
360 int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,
361 struct drm_property_blob *blob)
363 if (blob == state->mode_blob)
366 if (state->mode_blob)
367 drm_property_unreference_blob(state->mode_blob);
368 state->mode_blob = NULL;
371 if (blob->length != sizeof(struct drm_mode_modeinfo) ||
372 drm_mode_convert_umode(&state->mode,
373 (const struct drm_mode_modeinfo *)
377 state->mode_blob = drm_property_reference_blob(blob);
378 state->enable = true;
379 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
380 state->mode.name, state);
382 memset(&state->mode, 0, sizeof(state->mode));
383 state->enable = false;
384 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
390 EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc);
393 * drm_atomic_crtc_set_property - set property on CRTC
394 * @crtc: the drm CRTC to set a property on
395 * @state: the state object to update with the new property value
396 * @property: the property to set
397 * @val: the new property value
399 * Use this instead of calling crtc->atomic_set_property directly.
400 * This function handles generic/core properties and calls out to
401 * driver's ->atomic_set_property() for driver properties. To ensure
402 * consistent behavior you must call this function rather than the
403 * driver hook directly.
406 * Zero on success, error code on failure
408 int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
409 struct drm_crtc_state *state, struct drm_property *property,
412 struct drm_device *dev = crtc->dev;
413 struct drm_mode_config *config = &dev->mode_config;
416 if (property == config->prop_active)
418 else if (property == config->prop_mode_id) {
419 struct drm_property_blob *mode =
420 drm_property_lookup_blob(dev, val);
421 ret = drm_atomic_set_mode_prop_for_crtc(state, mode);
423 drm_property_unreference_blob(mode);
426 else if (crtc->funcs->atomic_set_property)
427 return crtc->funcs->atomic_set_property(crtc, state, property, val);
433 EXPORT_SYMBOL(drm_atomic_crtc_set_property);
436 * This function handles generic/core properties and calls out to
437 * driver's ->atomic_get_property() for driver properties. To ensure
438 * consistent behavior you must call this function rather than the
439 * driver hook directly.
442 drm_atomic_crtc_get_property(struct drm_crtc *crtc,
443 const struct drm_crtc_state *state,
444 struct drm_property *property, uint64_t *val)
446 struct drm_device *dev = crtc->dev;
447 struct drm_mode_config *config = &dev->mode_config;
449 if (property == config->prop_active)
450 *val = state->active;
451 else if (property == config->prop_mode_id)
452 *val = (state->mode_blob) ? state->mode_blob->base.id : 0;
453 else if (crtc->funcs->atomic_get_property)
454 return crtc->funcs->atomic_get_property(crtc, state, property, val);
462 * drm_atomic_crtc_check - check crtc state
463 * @crtc: crtc to check
464 * @state: crtc state to check
466 * Provides core sanity checks for crtc state.
469 * Zero on success, error code on failure
471 static int drm_atomic_crtc_check(struct drm_crtc *crtc,
472 struct drm_crtc_state *state)
474 /* NOTE: we explicitly don't enforce constraints such as primary
475 * layer covering entire screen, since that is something we want
476 * to allow (on hw that supports it). For hw that does not, it
477 * should be checked in driver's crtc->atomic_check() vfunc.
479 * TODO: Add generic modeset state checks once we support those.
482 if (state->active && !state->enable) {
483 DRM_DEBUG_ATOMIC("[CRTC:%d] active without enabled\n",
488 /* The state->enable vs. state->mode_blob checks can be WARN_ON,
489 * as this is a kernel-internal detail that userspace should never
490 * be able to trigger. */
491 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
492 WARN_ON(state->enable && !state->mode_blob)) {
493 DRM_DEBUG_ATOMIC("[CRTC:%d] enabled without mode blob\n",
498 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
499 WARN_ON(!state->enable && state->mode_blob)) {
500 DRM_DEBUG_ATOMIC("[CRTC:%d] disabled with mode blob\n",
509 * drm_atomic_get_plane_state - get plane state
510 * @state: global atomic state object
511 * @plane: plane to get state object for
513 * This function returns the plane state for the given plane, allocating it if
514 * needed. It will also grab the relevant plane lock to make sure that the state
519 * Either the allocated state or the error code encoded into the pointer. When
520 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
521 * entire atomic sequence must be restarted. All other errors are fatal.
523 struct drm_plane_state *
524 drm_atomic_get_plane_state(struct drm_atomic_state *state,
525 struct drm_plane *plane)
527 int ret, index = drm_plane_index(plane);
528 struct drm_plane_state *plane_state;
530 plane_state = drm_atomic_get_existing_plane_state(state, plane);
534 ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx);
538 plane_state = plane->funcs->atomic_duplicate_state(plane);
540 return ERR_PTR(-ENOMEM);
542 state->plane_states[index] = plane_state;
543 state->planes[index] = plane;
544 plane_state->state = state;
546 DRM_DEBUG_ATOMIC("Added [PLANE:%d] %p state to %p\n",
547 plane->base.id, plane_state, state);
549 if (plane_state->crtc) {
550 struct drm_crtc_state *crtc_state;
552 crtc_state = drm_atomic_get_crtc_state(state,
554 if (IS_ERR(crtc_state))
555 return ERR_CAST(crtc_state);
560 EXPORT_SYMBOL(drm_atomic_get_plane_state);
563 * drm_atomic_plane_set_property - set property on plane
564 * @plane: the drm plane to set a property on
565 * @state: the state object to update with the new property value
566 * @property: the property to set
567 * @val: the new property value
569 * Use this instead of calling plane->atomic_set_property directly.
570 * This function handles generic/core properties and calls out to
571 * driver's ->atomic_set_property() for driver properties. To ensure
572 * consistent behavior you must call this function rather than the
573 * driver hook directly.
576 * Zero on success, error code on failure
578 int drm_atomic_plane_set_property(struct drm_plane *plane,
579 struct drm_plane_state *state, struct drm_property *property,
582 struct drm_device *dev = plane->dev;
583 struct drm_mode_config *config = &dev->mode_config;
585 if (property == config->prop_fb_id) {
586 struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, val);
587 drm_atomic_set_fb_for_plane(state, fb);
589 drm_framebuffer_unreference(fb);
590 } else if (property == config->prop_crtc_id) {
591 struct drm_crtc *crtc = drm_crtc_find(dev, val);
592 return drm_atomic_set_crtc_for_plane(state, crtc);
593 } else if (property == config->prop_crtc_x) {
594 state->crtc_x = U642I64(val);
595 } else if (property == config->prop_crtc_y) {
596 state->crtc_y = U642I64(val);
597 } else if (property == config->prop_crtc_w) {
599 } else if (property == config->prop_crtc_h) {
601 } else if (property == config->prop_src_x) {
603 } else if (property == config->prop_src_y) {
605 } else if (property == config->prop_src_w) {
607 } else if (property == config->prop_src_h) {
609 } else if (property == config->rotation_property) {
610 state->rotation = val;
611 } else if (plane->funcs->atomic_set_property) {
612 return plane->funcs->atomic_set_property(plane, state,
620 EXPORT_SYMBOL(drm_atomic_plane_set_property);
623 * This function handles generic/core properties and calls out to
624 * driver's ->atomic_get_property() for driver properties. To ensure
625 * consistent behavior you must call this function rather than the
626 * driver hook directly.
629 drm_atomic_plane_get_property(struct drm_plane *plane,
630 const struct drm_plane_state *state,
631 struct drm_property *property, uint64_t *val)
633 struct drm_device *dev = plane->dev;
634 struct drm_mode_config *config = &dev->mode_config;
636 if (property == config->prop_fb_id) {
637 *val = (state->fb) ? state->fb->base.id : 0;
638 } else if (property == config->prop_crtc_id) {
639 *val = (state->crtc) ? state->crtc->base.id : 0;
640 } else if (property == config->prop_crtc_x) {
641 *val = I642U64(state->crtc_x);
642 } else if (property == config->prop_crtc_y) {
643 *val = I642U64(state->crtc_y);
644 } else if (property == config->prop_crtc_w) {
645 *val = state->crtc_w;
646 } else if (property == config->prop_crtc_h) {
647 *val = state->crtc_h;
648 } else if (property == config->prop_src_x) {
650 } else if (property == config->prop_src_y) {
652 } else if (property == config->prop_src_w) {
654 } else if (property == config->prop_src_h) {
656 } else if (property == config->rotation_property) {
657 *val = state->rotation;
658 } else if (plane->funcs->atomic_get_property) {
659 return plane->funcs->atomic_get_property(plane, state, property, val);
668 plane_switching_crtc(struct drm_atomic_state *state,
669 struct drm_plane *plane,
670 struct drm_plane_state *plane_state)
672 if (!plane->state->crtc || !plane_state->crtc)
675 if (plane->state->crtc == plane_state->crtc)
678 /* This could be refined, but currently there's no helper or driver code
679 * to implement direct switching of active planes nor userspace to take
680 * advantage of more direct plane switching without the intermediate
687 * drm_atomic_plane_check - check plane state
688 * @plane: plane to check
689 * @state: plane state to check
691 * Provides core sanity checks for plane state.
694 * Zero on success, error code on failure
696 static int drm_atomic_plane_check(struct drm_plane *plane,
697 struct drm_plane_state *state)
699 unsigned int fb_width, fb_height;
702 /* either *both* CRTC and FB must be set, or neither */
703 if (WARN_ON(state->crtc && !state->fb)) {
704 DRM_DEBUG_ATOMIC("CRTC set but no FB\n");
706 } else if (WARN_ON(state->fb && !state->crtc)) {
707 DRM_DEBUG_ATOMIC("FB set but no CRTC\n");
711 /* if disabled, we don't care about the rest of the state: */
715 /* Check whether this plane is usable on this CRTC */
716 if (!(plane->possible_crtcs & drm_crtc_mask(state->crtc))) {
717 DRM_DEBUG_ATOMIC("Invalid crtc for plane\n");
721 /* Check whether this plane supports the fb pixel format. */
722 ret = drm_plane_check_pixel_format(plane, state->fb->pixel_format);
724 DRM_DEBUG_ATOMIC("Invalid pixel format %s\n",
725 drm_get_format_name(state->fb->pixel_format));
729 /* Give drivers some help against integer overflows */
730 if (state->crtc_w > INT_MAX ||
731 state->crtc_x > INT_MAX - (int32_t) state->crtc_w ||
732 state->crtc_h > INT_MAX ||
733 state->crtc_y > INT_MAX - (int32_t) state->crtc_h) {
734 DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n",
735 state->crtc_w, state->crtc_h,
736 state->crtc_x, state->crtc_y);
740 fb_width = state->fb->width << 16;
741 fb_height = state->fb->height << 16;
743 /* Make sure source coordinates are inside the fb. */
744 if (state->src_w > fb_width ||
745 state->src_x > fb_width - state->src_w ||
746 state->src_h > fb_height ||
747 state->src_y > fb_height - state->src_h) {
748 DRM_DEBUG_ATOMIC("Invalid source coordinates "
749 "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
750 state->src_w >> 16, ((state->src_w & 0xffff) * 15625) >> 10,
751 state->src_h >> 16, ((state->src_h & 0xffff) * 15625) >> 10,
752 state->src_x >> 16, ((state->src_x & 0xffff) * 15625) >> 10,
753 state->src_y >> 16, ((state->src_y & 0xffff) * 15625) >> 10);
757 if (plane_switching_crtc(state->state, plane, state)) {
758 DRM_DEBUG_ATOMIC("[PLANE:%d] switching CRTC directly\n",
767 * drm_atomic_get_connector_state - get connector state
768 * @state: global atomic state object
769 * @connector: connector to get state object for
771 * This function returns the connector state for the given connector,
772 * allocating it if needed. It will also grab the relevant connector lock to
773 * make sure that the state is consistent.
777 * Either the allocated state or the error code encoded into the pointer. When
778 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
779 * entire atomic sequence must be restarted. All other errors are fatal.
781 struct drm_connector_state *
782 drm_atomic_get_connector_state(struct drm_atomic_state *state,
783 struct drm_connector *connector)
786 struct drm_mode_config *config = &connector->dev->mode_config;
787 struct drm_connector_state *connector_state;
789 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
793 index = drm_connector_index(connector);
796 * Construction of atomic state updates can race with a connector
797 * hot-add which might overflow. In this case flip the table and just
798 * restart the entire ioctl - no one is fast enough to livelock a cpu
799 * with physical hotplug events anyway.
801 * Note that we only grab the indexes once we have the right lock to
802 * prevent hotplug/unplugging of connectors. So removal is no problem,
803 * at most the array is a bit too large.
805 if (index >= state->num_connector) {
806 DRM_DEBUG_ATOMIC("Hot-added connector would overflow state array, restarting\n");
807 return ERR_PTR(-EAGAIN);
810 if (state->connector_states[index])
811 return state->connector_states[index];
813 connector_state = connector->funcs->atomic_duplicate_state(connector);
814 if (!connector_state)
815 return ERR_PTR(-ENOMEM);
817 state->connector_states[index] = connector_state;
818 state->connectors[index] = connector;
819 connector_state->state = state;
821 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d] %p state to %p\n",
822 connector->base.id, connector_state, state);
824 if (connector_state->crtc) {
825 struct drm_crtc_state *crtc_state;
827 crtc_state = drm_atomic_get_crtc_state(state,
828 connector_state->crtc);
829 if (IS_ERR(crtc_state))
830 return ERR_CAST(crtc_state);
833 return connector_state;
835 EXPORT_SYMBOL(drm_atomic_get_connector_state);
838 * drm_atomic_connector_set_property - set property on connector.
839 * @connector: the drm connector to set a property on
840 * @state: the state object to update with the new property value
841 * @property: the property to set
842 * @val: the new property value
844 * Use this instead of calling connector->atomic_set_property directly.
845 * This function handles generic/core properties and calls out to
846 * driver's ->atomic_set_property() for driver properties. To ensure
847 * consistent behavior you must call this function rather than the
848 * driver hook directly.
851 * Zero on success, error code on failure
853 int drm_atomic_connector_set_property(struct drm_connector *connector,
854 struct drm_connector_state *state, struct drm_property *property,
857 struct drm_device *dev = connector->dev;
858 struct drm_mode_config *config = &dev->mode_config;
860 if (property == config->prop_crtc_id) {
861 struct drm_crtc *crtc = drm_crtc_find(dev, val);
862 return drm_atomic_set_crtc_for_connector(state, crtc);
863 } else if (property == config->dpms_property) {
864 /* setting DPMS property requires special handling, which
865 * is done in legacy setprop path for us. Disallow (for
866 * now?) atomic writes to DPMS property:
869 } else if (connector->funcs->atomic_set_property) {
870 return connector->funcs->atomic_set_property(connector,
871 state, property, val);
876 EXPORT_SYMBOL(drm_atomic_connector_set_property);
879 * This function handles generic/core properties and calls out to
880 * driver's ->atomic_get_property() for driver properties. To ensure
881 * consistent behavior you must call this function rather than the
882 * driver hook directly.
885 drm_atomic_connector_get_property(struct drm_connector *connector,
886 const struct drm_connector_state *state,
887 struct drm_property *property, uint64_t *val)
889 struct drm_device *dev = connector->dev;
890 struct drm_mode_config *config = &dev->mode_config;
892 if (property == config->prop_crtc_id) {
893 *val = (state->crtc) ? state->crtc->base.id : 0;
894 } else if (property == config->dpms_property) {
895 *val = connector->dpms;
896 } else if (connector->funcs->atomic_get_property) {
897 return connector->funcs->atomic_get_property(connector,
898 state, property, val);
906 int drm_atomic_get_property(struct drm_mode_object *obj,
907 struct drm_property *property, uint64_t *val)
909 struct drm_device *dev = property->dev;
913 case DRM_MODE_OBJECT_CONNECTOR: {
914 struct drm_connector *connector = obj_to_connector(obj);
915 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
916 ret = drm_atomic_connector_get_property(connector,
917 connector->state, property, val);
920 case DRM_MODE_OBJECT_CRTC: {
921 struct drm_crtc *crtc = obj_to_crtc(obj);
922 WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
923 ret = drm_atomic_crtc_get_property(crtc,
924 crtc->state, property, val);
927 case DRM_MODE_OBJECT_PLANE: {
928 struct drm_plane *plane = obj_to_plane(obj);
929 WARN_ON(!drm_modeset_is_locked(&plane->mutex));
930 ret = drm_atomic_plane_get_property(plane,
931 plane->state, property, val);
943 * drm_atomic_set_crtc_for_plane - set crtc for plane
944 * @plane_state: the plane whose incoming state to update
945 * @crtc: crtc to use for the plane
947 * Changing the assigned crtc for a plane requires us to grab the lock and state
948 * for the new crtc, as needed. This function takes care of all these details
949 * besides updating the pointer in the state object itself.
952 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
953 * then the w/w mutex code has detected a deadlock and the entire atomic
954 * sequence must be restarted. All other errors are fatal.
957 drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
958 struct drm_crtc *crtc)
960 struct drm_plane *plane = plane_state->plane;
961 struct drm_crtc_state *crtc_state;
963 if (plane_state->crtc) {
964 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
966 if (WARN_ON(IS_ERR(crtc_state)))
967 return PTR_ERR(crtc_state);
969 crtc_state->plane_mask &= ~(1 << drm_plane_index(plane));
972 plane_state->crtc = crtc;
975 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
977 if (IS_ERR(crtc_state))
978 return PTR_ERR(crtc_state);
979 crtc_state->plane_mask |= (1 << drm_plane_index(plane));
983 DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d]\n",
984 plane_state, crtc->base.id);
986 DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n",
991 EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane);
994 * drm_atomic_set_fb_for_plane - set framebuffer for plane
995 * @plane_state: atomic state object for the plane
996 * @fb: fb to use for the plane
998 * Changing the assigned framebuffer for a plane requires us to grab a reference
999 * to the new fb and drop the reference to the old fb, if there is one. This
1000 * function takes care of all these details besides updating the pointer in the
1001 * state object itself.
1004 drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
1005 struct drm_framebuffer *fb)
1007 if (plane_state->fb)
1008 drm_framebuffer_unreference(plane_state->fb);
1010 drm_framebuffer_reference(fb);
1011 plane_state->fb = fb;
1014 DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n",
1015 fb->base.id, plane_state);
1017 DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n",
1020 EXPORT_SYMBOL(drm_atomic_set_fb_for_plane);
1023 * drm_atomic_set_crtc_for_connector - set crtc for connector
1024 * @conn_state: atomic state object for the connector
1025 * @crtc: crtc to use for the connector
1027 * Changing the assigned crtc for a connector requires us to grab the lock and
1028 * state for the new crtc, as needed. This function takes care of all these
1029 * details besides updating the pointer in the state object itself.
1032 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1033 * then the w/w mutex code has detected a deadlock and the entire atomic
1034 * sequence must be restarted. All other errors are fatal.
1037 drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
1038 struct drm_crtc *crtc)
1040 struct drm_crtc_state *crtc_state;
1043 crtc_state = drm_atomic_get_crtc_state(conn_state->state, crtc);
1044 if (IS_ERR(crtc_state))
1045 return PTR_ERR(crtc_state);
1048 conn_state->crtc = crtc;
1051 DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d]\n",
1052 conn_state, crtc->base.id);
1054 DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n",
1059 EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector);
1062 * drm_atomic_add_affected_connectors - add connectors for crtc
1063 * @state: atomic state
1066 * This function walks the current configuration and adds all connectors
1067 * currently using @crtc to the atomic configuration @state. Note that this
1068 * function must acquire the connection mutex. This can potentially cause
1069 * unneeded seralization if the update is just for the planes on one crtc. Hence
1070 * drivers and helpers should only call this when really needed (e.g. when a
1071 * full modeset needs to happen due to some change).
1074 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1075 * then the w/w mutex code has detected a deadlock and the entire atomic
1076 * sequence must be restarted. All other errors are fatal.
1079 drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
1080 struct drm_crtc *crtc)
1082 struct drm_mode_config *config = &state->dev->mode_config;
1083 struct drm_connector *connector;
1084 struct drm_connector_state *conn_state;
1087 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
1091 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d] to %p\n",
1092 crtc->base.id, state);
1095 * Changed connectors are already in @state, so only need to look at the
1096 * current configuration.
1098 drm_for_each_connector(connector, state->dev) {
1099 if (connector->state->crtc != crtc)
1102 conn_state = drm_atomic_get_connector_state(state, connector);
1103 if (IS_ERR(conn_state))
1104 return PTR_ERR(conn_state);
1109 EXPORT_SYMBOL(drm_atomic_add_affected_connectors);
1112 * drm_atomic_add_affected_planes - add planes for crtc
1113 * @state: atomic state
1116 * This function walks the current configuration and adds all planes
1117 * currently used by @crtc to the atomic configuration @state. This is useful
1118 * when an atomic commit also needs to check all currently enabled plane on
1119 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1120 * to avoid special code to force-enable all planes.
1122 * Since acquiring a plane state will always also acquire the w/w mutex of the
1123 * current CRTC for that plane (if there is any) adding all the plane states for
1124 * a CRTC will not reduce parallism of atomic updates.
1127 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1128 * then the w/w mutex code has detected a deadlock and the entire atomic
1129 * sequence must be restarted. All other errors are fatal.
1132 drm_atomic_add_affected_planes(struct drm_atomic_state *state,
1133 struct drm_crtc *crtc)
1135 struct drm_plane *plane;
1137 WARN_ON(!drm_atomic_get_existing_crtc_state(state, crtc));
1139 drm_for_each_plane_mask(plane, state->dev, crtc->state->plane_mask) {
1140 struct drm_plane_state *plane_state =
1141 drm_atomic_get_plane_state(state, plane);
1143 if (IS_ERR(plane_state))
1144 return PTR_ERR(plane_state);
1148 EXPORT_SYMBOL(drm_atomic_add_affected_planes);
1151 * drm_atomic_connectors_for_crtc - count number of connected outputs
1152 * @state: atomic state
1155 * This function counts all connectors which will be connected to @crtc
1156 * according to @state. Useful to recompute the enable state for @crtc.
1159 drm_atomic_connectors_for_crtc(struct drm_atomic_state *state,
1160 struct drm_crtc *crtc)
1162 struct drm_connector *connector;
1163 struct drm_connector_state *conn_state;
1165 int i, num_connected_connectors = 0;
1167 for_each_connector_in_state(state, connector, conn_state, i) {
1168 if (conn_state->crtc == crtc)
1169 num_connected_connectors++;
1172 DRM_DEBUG_ATOMIC("State %p has %i connectors for [CRTC:%d]\n",
1173 state, num_connected_connectors, crtc->base.id);
1175 return num_connected_connectors;
1177 EXPORT_SYMBOL(drm_atomic_connectors_for_crtc);
1180 * drm_atomic_legacy_backoff - locking backoff for legacy ioctls
1181 * @state: atomic state
1183 * This function should be used by legacy entry points which don't understand
1184 * -EDEADLK semantics. For simplicity this one will grab all modeset locks after
1185 * the slowpath completed.
1187 void drm_atomic_legacy_backoff(struct drm_atomic_state *state)
1192 drm_modeset_backoff(state->acquire_ctx);
1194 ret = drm_modeset_lock(&state->dev->mode_config.connection_mutex,
1195 state->acquire_ctx);
1198 ret = drm_modeset_lock_all_crtcs(state->dev,
1199 state->acquire_ctx);
1203 EXPORT_SYMBOL(drm_atomic_legacy_backoff);
1206 * drm_atomic_check_only - check whether a given config would work
1207 * @state: atomic configuration to check
1209 * Note that this function can return -EDEADLK if the driver needed to acquire
1210 * more locks but encountered a deadlock. The caller must then do the usual w/w
1211 * backoff dance and restart. All other errors are fatal.
1214 * 0 on success, negative error code on failure.
1216 int drm_atomic_check_only(struct drm_atomic_state *state)
1218 struct drm_device *dev = state->dev;
1219 struct drm_mode_config *config = &dev->mode_config;
1220 struct drm_plane *plane;
1221 struct drm_plane_state *plane_state;
1222 struct drm_crtc *crtc;
1223 struct drm_crtc_state *crtc_state;
1226 DRM_DEBUG_ATOMIC("checking %p\n", state);
1228 for_each_plane_in_state(state, plane, plane_state, i) {
1229 ret = drm_atomic_plane_check(plane, plane_state);
1231 DRM_DEBUG_ATOMIC("[PLANE:%d] atomic core check failed\n",
1237 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1238 ret = drm_atomic_crtc_check(crtc, crtc_state);
1240 DRM_DEBUG_ATOMIC("[CRTC:%d] atomic core check failed\n",
1246 if (config->funcs->atomic_check)
1247 ret = config->funcs->atomic_check(state->dev, state);
1249 if (!state->allow_modeset) {
1250 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1251 if (drm_atomic_crtc_needs_modeset(crtc_state)) {
1252 DRM_DEBUG_ATOMIC("[CRTC:%d] requires full modeset\n",
1261 EXPORT_SYMBOL(drm_atomic_check_only);
1264 * drm_atomic_commit - commit configuration atomically
1265 * @state: atomic configuration to check
1267 * Note that this function can return -EDEADLK if the driver needed to acquire
1268 * more locks but encountered a deadlock. The caller must then do the usual w/w
1269 * backoff dance and restart. All other errors are fatal.
1271 * Also note that on successful execution ownership of @state is transferred
1272 * from the caller of this function to the function itself. The caller must not
1273 * free or in any other way access @state. If the function fails then the caller
1274 * must clean up @state itself.
1277 * 0 on success, negative error code on failure.
1279 int drm_atomic_commit(struct drm_atomic_state *state)
1281 struct drm_mode_config *config = &state->dev->mode_config;
1284 ret = drm_atomic_check_only(state);
1288 DRM_DEBUG_ATOMIC("commiting %p\n", state);
1290 return config->funcs->atomic_commit(state->dev, state, false);
1292 EXPORT_SYMBOL(drm_atomic_commit);
1295 * drm_atomic_async_commit - atomic&async configuration commit
1296 * @state: atomic configuration to check
1298 * Note that this function can return -EDEADLK if the driver needed to acquire
1299 * more locks but encountered a deadlock. The caller must then do the usual w/w
1300 * backoff dance and restart. All other errors are fatal.
1302 * Also note that on successful execution ownership of @state is transferred
1303 * from the caller of this function to the function itself. The caller must not
1304 * free or in any other way access @state. If the function fails then the caller
1305 * must clean up @state itself.
1308 * 0 on success, negative error code on failure.
1310 int drm_atomic_async_commit(struct drm_atomic_state *state)
1312 struct drm_mode_config *config = &state->dev->mode_config;
1315 ret = drm_atomic_check_only(state);
1319 DRM_DEBUG_ATOMIC("commiting %p asynchronously\n", state);
1321 return config->funcs->atomic_commit(state->dev, state, true);
1323 EXPORT_SYMBOL(drm_atomic_async_commit);
1326 * The big monstor ioctl
1329 static struct drm_pending_vblank_event *create_vblank_event(
1330 struct drm_device *dev, struct drm_file *file_priv, uint64_t user_data)
1332 struct drm_pending_vblank_event *e = NULL;
1333 unsigned long flags;
1335 spin_lock_irqsave(&dev->event_lock, flags);
1336 if (file_priv->event_space < sizeof e->event) {
1337 spin_unlock_irqrestore(&dev->event_lock, flags);
1340 file_priv->event_space -= sizeof e->event;
1341 spin_unlock_irqrestore(&dev->event_lock, flags);
1343 e = kzalloc(sizeof *e, GFP_KERNEL);
1345 spin_lock_irqsave(&dev->event_lock, flags);
1346 file_priv->event_space += sizeof e->event;
1347 spin_unlock_irqrestore(&dev->event_lock, flags);
1351 e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
1352 e->event.base.length = sizeof e->event;
1353 e->event.user_data = user_data;
1354 e->base.event = &e->event.base;
1355 e->base.file_priv = file_priv;
1356 e->base.destroy = (void (*) (struct drm_pending_event *)) kfree;
1362 static void destroy_vblank_event(struct drm_device *dev,
1363 struct drm_file *file_priv, struct drm_pending_vblank_event *e)
1365 unsigned long flags;
1367 spin_lock_irqsave(&dev->event_lock, flags);
1368 file_priv->event_space += sizeof e->event;
1369 spin_unlock_irqrestore(&dev->event_lock, flags);
1373 static int atomic_set_prop(struct drm_atomic_state *state,
1374 struct drm_mode_object *obj, struct drm_property *prop,
1375 uint64_t prop_value)
1377 struct drm_mode_object *ref;
1380 if (!drm_property_change_valid_get(prop, prop_value, &ref))
1383 switch (obj->type) {
1384 case DRM_MODE_OBJECT_CONNECTOR: {
1385 struct drm_connector *connector = obj_to_connector(obj);
1386 struct drm_connector_state *connector_state;
1388 connector_state = drm_atomic_get_connector_state(state, connector);
1389 if (IS_ERR(connector_state)) {
1390 ret = PTR_ERR(connector_state);
1394 ret = drm_atomic_connector_set_property(connector,
1395 connector_state, prop, prop_value);
1398 case DRM_MODE_OBJECT_CRTC: {
1399 struct drm_crtc *crtc = obj_to_crtc(obj);
1400 struct drm_crtc_state *crtc_state;
1402 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1403 if (IS_ERR(crtc_state)) {
1404 ret = PTR_ERR(crtc_state);
1408 ret = drm_atomic_crtc_set_property(crtc,
1409 crtc_state, prop, prop_value);
1412 case DRM_MODE_OBJECT_PLANE: {
1413 struct drm_plane *plane = obj_to_plane(obj);
1414 struct drm_plane_state *plane_state;
1416 plane_state = drm_atomic_get_plane_state(state, plane);
1417 if (IS_ERR(plane_state)) {
1418 ret = PTR_ERR(plane_state);
1422 ret = drm_atomic_plane_set_property(plane,
1423 plane_state, prop, prop_value);
1431 drm_property_change_valid_put(prop, ref);
1435 int drm_mode_atomic_ioctl(struct drm_device *dev,
1436 void *data, struct drm_file *file_priv)
1438 struct drm_mode_atomic *arg = data;
1439 uint32_t __user *objs_ptr = (uint32_t __user *)(unsigned long)(arg->objs_ptr);
1440 uint32_t __user *count_props_ptr = (uint32_t __user *)(unsigned long)(arg->count_props_ptr);
1441 uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
1442 uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr);
1443 unsigned int copied_objs, copied_props;
1444 struct drm_atomic_state *state;
1445 struct drm_modeset_acquire_ctx ctx;
1446 struct drm_plane *plane;
1447 struct drm_crtc *crtc;
1448 struct drm_crtc_state *crtc_state;
1449 unsigned plane_mask = 0;
1453 /* disallow for drivers not supporting atomic: */
1454 if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
1457 /* disallow for userspace that has not enabled atomic cap (even
1458 * though this may be a bit overkill, since legacy userspace
1459 * wouldn't know how to call this ioctl)
1461 if (!file_priv->atomic)
1464 if (arg->flags & ~DRM_MODE_ATOMIC_FLAGS)
1470 if ((arg->flags & DRM_MODE_PAGE_FLIP_ASYNC) &&
1471 !dev->mode_config.async_page_flip)
1474 /* can't test and expect an event at the same time. */
1475 if ((arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) &&
1476 (arg->flags & DRM_MODE_PAGE_FLIP_EVENT))
1479 drm_modeset_acquire_init(&ctx, 0);
1481 state = drm_atomic_state_alloc(dev);
1485 state->acquire_ctx = &ctx;
1486 state->allow_modeset = !!(arg->flags & DRM_MODE_ATOMIC_ALLOW_MODESET);
1492 for (i = 0; i < arg->count_objs; i++) {
1493 uint32_t obj_id, count_props;
1494 struct drm_mode_object *obj;
1496 if (get_user(obj_id, objs_ptr + copied_objs)) {
1501 obj = drm_mode_object_find(dev, obj_id, DRM_MODE_OBJECT_ANY);
1502 if (!obj || !obj->properties) {
1507 if (get_user(count_props, count_props_ptr + copied_objs)) {
1514 for (j = 0; j < count_props; j++) {
1516 uint64_t prop_value;
1517 struct drm_property *prop;
1519 if (get_user(prop_id, props_ptr + copied_props)) {
1524 prop = drm_property_find(dev, prop_id);
1530 if (copy_from_user(&prop_value,
1531 prop_values_ptr + copied_props,
1532 sizeof(prop_value))) {
1537 ret = atomic_set_prop(state, obj, prop, prop_value);
1544 if (obj->type == DRM_MODE_OBJECT_PLANE && count_props &&
1545 !(arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)) {
1546 plane = obj_to_plane(obj);
1547 plane_mask |= (1 << drm_plane_index(plane));
1548 plane->old_fb = plane->fb;
1552 if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1553 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1554 struct drm_pending_vblank_event *e;
1556 e = create_vblank_event(dev, file_priv, arg->user_data);
1562 crtc_state->event = e;
1566 if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) {
1568 * Unlike commit, check_only does not clean up state.
1569 * Below we call drm_atomic_state_free for it.
1571 ret = drm_atomic_check_only(state);
1572 } else if (arg->flags & DRM_MODE_ATOMIC_NONBLOCK) {
1573 ret = drm_atomic_async_commit(state);
1575 ret = drm_atomic_commit(state);
1579 /* if succeeded, fixup legacy plane crtc/fb ptrs before dropping
1580 * locks (ie. while it is still safe to deref plane->state). We
1581 * need to do this here because the driver entry points cannot
1582 * distinguish between legacy and atomic ioctls.
1584 drm_for_each_plane_mask(plane, dev, plane_mask) {
1586 struct drm_framebuffer *new_fb = plane->state->fb;
1588 drm_framebuffer_reference(new_fb);
1590 plane->crtc = plane->state->crtc;
1593 drm_framebuffer_unreference(plane->old_fb);
1595 plane->old_fb = NULL;
1598 if (ret && arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1600 * TEST_ONLY and PAGE_FLIP_EVENT are mutually exclusive,
1601 * if they weren't, this code should be called on success
1602 * for TEST_ONLY too.
1605 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1606 if (!crtc_state->event)
1609 destroy_vblank_event(dev, file_priv,
1614 if (ret == -EDEADLK) {
1615 drm_atomic_state_clear(state);
1616 drm_modeset_backoff(&ctx);
1620 if (ret || arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)
1621 drm_atomic_state_free(state);
1623 drm_modeset_drop_locks(&ctx);
1624 drm_modeset_acquire_fini(&ctx);