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>
29 #include <linux/sync_file.h>
31 #include <drm/drm_atomic.h>
32 #include <drm/drm_atomic_uapi.h>
33 #include <drm/drm_bridge.h>
34 #include <drm/drm_debugfs.h>
35 #include <drm/drm_device.h>
36 #include <drm/drm_drv.h>
37 #include <drm/drm_file.h>
38 #include <drm/drm_fourcc.h>
39 #include <drm/drm_mode.h>
40 #include <drm/drm_print.h>
41 #include <drm/drm_writeback.h>
43 #include "drm_crtc_internal.h"
44 #include "drm_internal.h"
46 void __drm_crtc_commit_free(struct kref
*kref
)
48 struct drm_crtc_commit
*commit
=
49 container_of(kref
, struct drm_crtc_commit
, ref
);
53 EXPORT_SYMBOL(__drm_crtc_commit_free
);
56 * drm_atomic_state_default_release -
57 * release memory initialized by drm_atomic_state_init
58 * @state: atomic state
60 * Free all the memory allocated by drm_atomic_state_init.
61 * This should only be used by drivers which are still subclassing
62 * &drm_atomic_state and haven't switched to &drm_private_state yet.
64 void drm_atomic_state_default_release(struct drm_atomic_state
*state
)
66 kfree(state
->connectors
);
69 kfree(state
->private_objs
);
71 EXPORT_SYMBOL(drm_atomic_state_default_release
);
74 * drm_atomic_state_init - init new atomic state
76 * @state: atomic state
78 * Default implementation for filling in a new atomic state.
79 * This should only be used by drivers which are still subclassing
80 * &drm_atomic_state and haven't switched to &drm_private_state yet.
83 drm_atomic_state_init(struct drm_device
*dev
, struct drm_atomic_state
*state
)
85 kref_init(&state
->ref
);
87 /* TODO legacy paths should maybe do a better job about
88 * setting this appropriately?
90 state
->allow_modeset
= true;
92 state
->crtcs
= kcalloc(dev
->mode_config
.num_crtc
,
93 sizeof(*state
->crtcs
), GFP_KERNEL
);
96 state
->planes
= kcalloc(dev
->mode_config
.num_total_plane
,
97 sizeof(*state
->planes
), GFP_KERNEL
);
103 DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state
);
107 drm_atomic_state_default_release(state
);
110 EXPORT_SYMBOL(drm_atomic_state_init
);
113 * drm_atomic_state_alloc - allocate atomic state
116 * This allocates an empty atomic state to track updates.
118 struct drm_atomic_state
*
119 drm_atomic_state_alloc(struct drm_device
*dev
)
121 struct drm_mode_config
*config
= &dev
->mode_config
;
123 if (!config
->funcs
->atomic_state_alloc
) {
124 struct drm_atomic_state
*state
;
126 state
= kzalloc(sizeof(*state
), GFP_KERNEL
);
129 if (drm_atomic_state_init(dev
, state
) < 0) {
136 return config
->funcs
->atomic_state_alloc(dev
);
138 EXPORT_SYMBOL(drm_atomic_state_alloc
);
141 * drm_atomic_state_default_clear - clear base atomic state
142 * @state: atomic state
144 * Default implementation for clearing atomic state.
145 * This should only be used by drivers which are still subclassing
146 * &drm_atomic_state and haven't switched to &drm_private_state yet.
148 void drm_atomic_state_default_clear(struct drm_atomic_state
*state
)
150 struct drm_device
*dev
= state
->dev
;
151 struct drm_mode_config
*config
= &dev
->mode_config
;
154 DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state
);
156 for (i
= 0; i
< state
->num_connector
; i
++) {
157 struct drm_connector
*connector
= state
->connectors
[i
].ptr
;
162 connector
->funcs
->atomic_destroy_state(connector
,
163 state
->connectors
[i
].state
);
164 state
->connectors
[i
].ptr
= NULL
;
165 state
->connectors
[i
].state
= NULL
;
166 state
->connectors
[i
].old_state
= NULL
;
167 state
->connectors
[i
].new_state
= NULL
;
168 drm_connector_put(connector
);
171 for (i
= 0; i
< config
->num_crtc
; i
++) {
172 struct drm_crtc
*crtc
= state
->crtcs
[i
].ptr
;
177 crtc
->funcs
->atomic_destroy_state(crtc
,
178 state
->crtcs
[i
].state
);
180 state
->crtcs
[i
].ptr
= NULL
;
181 state
->crtcs
[i
].state
= NULL
;
182 state
->crtcs
[i
].old_state
= NULL
;
183 state
->crtcs
[i
].new_state
= NULL
;
185 if (state
->crtcs
[i
].commit
) {
186 drm_crtc_commit_put(state
->crtcs
[i
].commit
);
187 state
->crtcs
[i
].commit
= NULL
;
191 for (i
= 0; i
< config
->num_total_plane
; i
++) {
192 struct drm_plane
*plane
= state
->planes
[i
].ptr
;
197 plane
->funcs
->atomic_destroy_state(plane
,
198 state
->planes
[i
].state
);
199 state
->planes
[i
].ptr
= NULL
;
200 state
->planes
[i
].state
= NULL
;
201 state
->planes
[i
].old_state
= NULL
;
202 state
->planes
[i
].new_state
= NULL
;
205 for (i
= 0; i
< state
->num_private_objs
; i
++) {
206 struct drm_private_obj
*obj
= state
->private_objs
[i
].ptr
;
208 obj
->funcs
->atomic_destroy_state(obj
,
209 state
->private_objs
[i
].state
);
210 state
->private_objs
[i
].ptr
= NULL
;
211 state
->private_objs
[i
].state
= NULL
;
212 state
->private_objs
[i
].old_state
= NULL
;
213 state
->private_objs
[i
].new_state
= NULL
;
215 state
->num_private_objs
= 0;
217 if (state
->fake_commit
) {
218 drm_crtc_commit_put(state
->fake_commit
);
219 state
->fake_commit
= NULL
;
222 EXPORT_SYMBOL(drm_atomic_state_default_clear
);
225 * drm_atomic_state_clear - clear state object
226 * @state: atomic state
228 * When the w/w mutex algorithm detects a deadlock we need to back off and drop
229 * all locks. So someone else could sneak in and change the current modeset
230 * configuration. Which means that all the state assembled in @state is no
231 * longer an atomic update to the current state, but to some arbitrary earlier
232 * state. Which could break assumptions the driver's
233 * &drm_mode_config_funcs.atomic_check likely relies on.
235 * Hence we must clear all cached state and completely start over, using this
238 void drm_atomic_state_clear(struct drm_atomic_state
*state
)
240 struct drm_device
*dev
= state
->dev
;
241 struct drm_mode_config
*config
= &dev
->mode_config
;
243 if (config
->funcs
->atomic_state_clear
)
244 config
->funcs
->atomic_state_clear(state
);
246 drm_atomic_state_default_clear(state
);
248 EXPORT_SYMBOL(drm_atomic_state_clear
);
251 * __drm_atomic_state_free - free all memory for an atomic state
252 * @ref: This atomic state to deallocate
254 * This frees all memory associated with an atomic state, including all the
255 * per-object state for planes, CRTCs and connectors.
257 void __drm_atomic_state_free(struct kref
*ref
)
259 struct drm_atomic_state
*state
= container_of(ref
, typeof(*state
), ref
);
260 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
262 drm_atomic_state_clear(state
);
264 DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state
);
266 if (config
->funcs
->atomic_state_free
) {
267 config
->funcs
->atomic_state_free(state
);
269 drm_atomic_state_default_release(state
);
273 EXPORT_SYMBOL(__drm_atomic_state_free
);
276 * drm_atomic_get_crtc_state - get CRTC state
277 * @state: global atomic state object
278 * @crtc: CRTC to get state object for
280 * This function returns the CRTC state for the given CRTC, allocating it if
281 * needed. It will also grab the relevant CRTC lock to make sure that the state
286 * Either the allocated state or the error code encoded into the pointer. When
287 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
288 * entire atomic sequence must be restarted. All other errors are fatal.
290 struct drm_crtc_state
*
291 drm_atomic_get_crtc_state(struct drm_atomic_state
*state
,
292 struct drm_crtc
*crtc
)
294 int ret
, index
= drm_crtc_index(crtc
);
295 struct drm_crtc_state
*crtc_state
;
297 WARN_ON(!state
->acquire_ctx
);
299 crtc_state
= drm_atomic_get_existing_crtc_state(state
, crtc
);
303 ret
= drm_modeset_lock(&crtc
->mutex
, state
->acquire_ctx
);
307 crtc_state
= crtc
->funcs
->atomic_duplicate_state(crtc
);
309 return ERR_PTR(-ENOMEM
);
311 state
->crtcs
[index
].state
= crtc_state
;
312 state
->crtcs
[index
].old_state
= crtc
->state
;
313 state
->crtcs
[index
].new_state
= crtc_state
;
314 state
->crtcs
[index
].ptr
= crtc
;
315 crtc_state
->state
= state
;
317 DRM_DEBUG_ATOMIC("Added [CRTC:%d:%s] %p state to %p\n",
318 crtc
->base
.id
, crtc
->name
, crtc_state
, state
);
322 EXPORT_SYMBOL(drm_atomic_get_crtc_state
);
324 static int drm_atomic_crtc_check(const struct drm_crtc_state
*old_crtc_state
,
325 const struct drm_crtc_state
*new_crtc_state
)
327 struct drm_crtc
*crtc
= new_crtc_state
->crtc
;
329 /* NOTE: we explicitly don't enforce constraints such as primary
330 * layer covering entire screen, since that is something we want
331 * to allow (on hw that supports it). For hw that does not, it
332 * should be checked in driver's crtc->atomic_check() vfunc.
334 * TODO: Add generic modeset state checks once we support those.
337 if (new_crtc_state
->active
&& !new_crtc_state
->enable
) {
338 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active without enabled\n",
339 crtc
->base
.id
, crtc
->name
);
343 /* The state->enable vs. state->mode_blob checks can be WARN_ON,
344 * as this is a kernel-internal detail that userspace should never
345 * be able to trigger. */
346 if (drm_core_check_feature(crtc
->dev
, DRIVER_ATOMIC
) &&
347 WARN_ON(new_crtc_state
->enable
&& !new_crtc_state
->mode_blob
)) {
348 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled without mode blob\n",
349 crtc
->base
.id
, crtc
->name
);
353 if (drm_core_check_feature(crtc
->dev
, DRIVER_ATOMIC
) &&
354 WARN_ON(!new_crtc_state
->enable
&& new_crtc_state
->mode_blob
)) {
355 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled with mode blob\n",
356 crtc
->base
.id
, crtc
->name
);
361 * Reject event generation for when a CRTC is off and stays off.
362 * It wouldn't be hard to implement this, but userspace has a track
363 * record of happily burning through 100% cpu (or worse, crash) when the
364 * display pipe is suspended. To avoid all that fun just reject updates
365 * that ask for events since likely that indicates a bug in the
366 * compositor's drawing loop. This is consistent with the vblank IOCTL
367 * and legacy page_flip IOCTL which also reject service on a disabled
370 if (new_crtc_state
->event
&&
371 !new_crtc_state
->active
&& !old_crtc_state
->active
) {
372 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requesting event but off\n",
373 crtc
->base
.id
, crtc
->name
);
380 static void drm_atomic_crtc_print_state(struct drm_printer
*p
,
381 const struct drm_crtc_state
*state
)
383 struct drm_crtc
*crtc
= state
->crtc
;
385 drm_printf(p
, "crtc[%u]: %s\n", crtc
->base
.id
, crtc
->name
);
386 drm_printf(p
, "\tenable=%d\n", state
->enable
);
387 drm_printf(p
, "\tactive=%d\n", state
->active
);
388 drm_printf(p
, "\tself_refresh_active=%d\n", state
->self_refresh_active
);
389 drm_printf(p
, "\tplanes_changed=%d\n", state
->planes_changed
);
390 drm_printf(p
, "\tmode_changed=%d\n", state
->mode_changed
);
391 drm_printf(p
, "\tactive_changed=%d\n", state
->active_changed
);
392 drm_printf(p
, "\tconnectors_changed=%d\n", state
->connectors_changed
);
393 drm_printf(p
, "\tcolor_mgmt_changed=%d\n", state
->color_mgmt_changed
);
394 drm_printf(p
, "\tplane_mask=%x\n", state
->plane_mask
);
395 drm_printf(p
, "\tconnector_mask=%x\n", state
->connector_mask
);
396 drm_printf(p
, "\tencoder_mask=%x\n", state
->encoder_mask
);
397 drm_printf(p
, "\tmode: " DRM_MODE_FMT
"\n", DRM_MODE_ARG(&state
->mode
));
399 if (crtc
->funcs
->atomic_print_state
)
400 crtc
->funcs
->atomic_print_state(p
, state
);
403 static int drm_atomic_connector_check(struct drm_connector
*connector
,
404 struct drm_connector_state
*state
)
406 struct drm_crtc_state
*crtc_state
;
407 struct drm_writeback_job
*writeback_job
= state
->writeback_job
;
408 const struct drm_display_info
*info
= &connector
->display_info
;
410 state
->max_bpc
= info
->bpc
? info
->bpc
: 8;
411 if (connector
->max_bpc_property
)
412 state
->max_bpc
= min(state
->max_bpc
, state
->max_requested_bpc
);
414 if ((connector
->connector_type
!= DRM_MODE_CONNECTOR_WRITEBACK
) || !writeback_job
)
417 if (writeback_job
->fb
&& !state
->crtc
) {
418 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] framebuffer without CRTC\n",
419 connector
->base
.id
, connector
->name
);
424 crtc_state
= drm_atomic_get_existing_crtc_state(state
->state
,
427 if (writeback_job
->fb
&& !crtc_state
->active
) {
428 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] has framebuffer, but [CRTC:%d] is off\n",
429 connector
->base
.id
, connector
->name
,
430 state
->crtc
->base
.id
);
434 if (!writeback_job
->fb
) {
435 if (writeback_job
->out_fence
) {
436 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] requesting out-fence without framebuffer\n",
437 connector
->base
.id
, connector
->name
);
441 drm_writeback_cleanup_job(writeback_job
);
442 state
->writeback_job
= NULL
;
449 * drm_atomic_get_plane_state - get plane state
450 * @state: global atomic state object
451 * @plane: plane to get state object for
453 * This function returns the plane state for the given plane, allocating it if
454 * needed. It will also grab the relevant plane lock to make sure that the state
459 * Either the allocated state or the error code encoded into the pointer. When
460 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
461 * entire atomic sequence must be restarted. All other errors are fatal.
463 struct drm_plane_state
*
464 drm_atomic_get_plane_state(struct drm_atomic_state
*state
,
465 struct drm_plane
*plane
)
467 int ret
, index
= drm_plane_index(plane
);
468 struct drm_plane_state
*plane_state
;
470 WARN_ON(!state
->acquire_ctx
);
472 /* the legacy pointers should never be set */
474 WARN_ON(plane
->old_fb
);
475 WARN_ON(plane
->crtc
);
477 plane_state
= drm_atomic_get_existing_plane_state(state
, plane
);
481 ret
= drm_modeset_lock(&plane
->mutex
, state
->acquire_ctx
);
485 plane_state
= plane
->funcs
->atomic_duplicate_state(plane
);
487 return ERR_PTR(-ENOMEM
);
489 state
->planes
[index
].state
= plane_state
;
490 state
->planes
[index
].ptr
= plane
;
491 state
->planes
[index
].old_state
= plane
->state
;
492 state
->planes
[index
].new_state
= plane_state
;
493 plane_state
->state
= state
;
495 DRM_DEBUG_ATOMIC("Added [PLANE:%d:%s] %p state to %p\n",
496 plane
->base
.id
, plane
->name
, plane_state
, state
);
498 if (plane_state
->crtc
) {
499 struct drm_crtc_state
*crtc_state
;
501 crtc_state
= drm_atomic_get_crtc_state(state
,
503 if (IS_ERR(crtc_state
))
504 return ERR_CAST(crtc_state
);
509 EXPORT_SYMBOL(drm_atomic_get_plane_state
);
512 plane_switching_crtc(const struct drm_plane_state
*old_plane_state
,
513 const struct drm_plane_state
*new_plane_state
)
515 if (!old_plane_state
->crtc
|| !new_plane_state
->crtc
)
518 if (old_plane_state
->crtc
== new_plane_state
->crtc
)
521 /* This could be refined, but currently there's no helper or driver code
522 * to implement direct switching of active planes nor userspace to take
523 * advantage of more direct plane switching without the intermediate
530 * drm_atomic_plane_check - check plane state
531 * @old_plane_state: old plane state to check
532 * @new_plane_state: new plane state to check
534 * Provides core sanity checks for plane state.
537 * Zero on success, error code on failure
539 static int drm_atomic_plane_check(const struct drm_plane_state
*old_plane_state
,
540 const struct drm_plane_state
*new_plane_state
)
542 struct drm_plane
*plane
= new_plane_state
->plane
;
543 struct drm_crtc
*crtc
= new_plane_state
->crtc
;
544 const struct drm_framebuffer
*fb
= new_plane_state
->fb
;
545 unsigned int fb_width
, fb_height
;
546 struct drm_mode_rect
*clips
;
550 /* either *both* CRTC and FB must be set, or neither */
552 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] CRTC set but no FB\n",
553 plane
->base
.id
, plane
->name
);
555 } else if (fb
&& !crtc
) {
556 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] FB set but no CRTC\n",
557 plane
->base
.id
, plane
->name
);
561 /* if disabled, we don't care about the rest of the state: */
565 /* Check whether this plane is usable on this CRTC */
566 if (!(plane
->possible_crtcs
& drm_crtc_mask(crtc
))) {
567 DRM_DEBUG_ATOMIC("Invalid [CRTC:%d:%s] for [PLANE:%d:%s]\n",
568 crtc
->base
.id
, crtc
->name
,
569 plane
->base
.id
, plane
->name
);
573 /* Check whether this plane supports the fb pixel format. */
574 ret
= drm_plane_check_pixel_format(plane
, fb
->format
->format
,
577 struct drm_format_name_buf format_name
;
578 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] invalid pixel format %s, modifier 0x%llx\n",
579 plane
->base
.id
, plane
->name
,
580 drm_get_format_name(fb
->format
->format
,
586 /* Give drivers some help against integer overflows */
587 if (new_plane_state
->crtc_w
> INT_MAX
||
588 new_plane_state
->crtc_x
> INT_MAX
- (int32_t) new_plane_state
->crtc_w
||
589 new_plane_state
->crtc_h
> INT_MAX
||
590 new_plane_state
->crtc_y
> INT_MAX
- (int32_t) new_plane_state
->crtc_h
) {
591 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] invalid CRTC coordinates %ux%u+%d+%d\n",
592 plane
->base
.id
, plane
->name
,
593 new_plane_state
->crtc_w
, new_plane_state
->crtc_h
,
594 new_plane_state
->crtc_x
, new_plane_state
->crtc_y
);
598 fb_width
= fb
->width
<< 16;
599 fb_height
= fb
->height
<< 16;
601 /* Make sure source coordinates are inside the fb. */
602 if (new_plane_state
->src_w
> fb_width
||
603 new_plane_state
->src_x
> fb_width
- new_plane_state
->src_w
||
604 new_plane_state
->src_h
> fb_height
||
605 new_plane_state
->src_y
> fb_height
- new_plane_state
->src_h
) {
606 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] invalid source coordinates "
607 "%u.%06ux%u.%06u+%u.%06u+%u.%06u (fb %ux%u)\n",
608 plane
->base
.id
, plane
->name
,
609 new_plane_state
->src_w
>> 16,
610 ((new_plane_state
->src_w
& 0xffff) * 15625) >> 10,
611 new_plane_state
->src_h
>> 16,
612 ((new_plane_state
->src_h
& 0xffff) * 15625) >> 10,
613 new_plane_state
->src_x
>> 16,
614 ((new_plane_state
->src_x
& 0xffff) * 15625) >> 10,
615 new_plane_state
->src_y
>> 16,
616 ((new_plane_state
->src_y
& 0xffff) * 15625) >> 10,
617 fb
->width
, fb
->height
);
621 clips
= drm_plane_get_damage_clips(new_plane_state
);
622 num_clips
= drm_plane_get_damage_clips_count(new_plane_state
);
624 /* Make sure damage clips are valid and inside the fb. */
625 while (num_clips
> 0) {
626 if (clips
->x1
>= clips
->x2
||
627 clips
->y1
>= clips
->y2
||
630 clips
->x2
> fb_width
||
631 clips
->y2
> fb_height
) {
632 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] invalid damage clip %d %d %d %d\n",
633 plane
->base
.id
, plane
->name
, clips
->x1
,
634 clips
->y1
, clips
->x2
, clips
->y2
);
641 if (plane_switching_crtc(old_plane_state
, new_plane_state
)) {
642 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] switching CRTC directly\n",
643 plane
->base
.id
, plane
->name
);
650 static void drm_atomic_plane_print_state(struct drm_printer
*p
,
651 const struct drm_plane_state
*state
)
653 struct drm_plane
*plane
= state
->plane
;
654 struct drm_rect src
= drm_plane_state_src(state
);
655 struct drm_rect dest
= drm_plane_state_dest(state
);
657 drm_printf(p
, "plane[%u]: %s\n", plane
->base
.id
, plane
->name
);
658 drm_printf(p
, "\tcrtc=%s\n", state
->crtc
? state
->crtc
->name
: "(null)");
659 drm_printf(p
, "\tfb=%u\n", state
->fb
? state
->fb
->base
.id
: 0);
661 drm_framebuffer_print_info(p
, 2, state
->fb
);
662 drm_printf(p
, "\tcrtc-pos=" DRM_RECT_FMT
"\n", DRM_RECT_ARG(&dest
));
663 drm_printf(p
, "\tsrc-pos=" DRM_RECT_FP_FMT
"\n", DRM_RECT_FP_ARG(&src
));
664 drm_printf(p
, "\trotation=%x\n", state
->rotation
);
665 drm_printf(p
, "\tnormalized-zpos=%x\n", state
->normalized_zpos
);
666 drm_printf(p
, "\tcolor-encoding=%s\n",
667 drm_get_color_encoding_name(state
->color_encoding
));
668 drm_printf(p
, "\tcolor-range=%s\n",
669 drm_get_color_range_name(state
->color_range
));
671 if (plane
->funcs
->atomic_print_state
)
672 plane
->funcs
->atomic_print_state(p
, state
);
676 * DOC: handling driver private state
678 * Very often the DRM objects exposed to userspace in the atomic modeset api
679 * (&drm_connector, &drm_crtc and &drm_plane) do not map neatly to the
680 * underlying hardware. Especially for any kind of shared resources (e.g. shared
681 * clocks, scaler units, bandwidth and fifo limits shared among a group of
682 * planes or CRTCs, and so on) it makes sense to model these as independent
683 * objects. Drivers then need to do similar state tracking and commit ordering for
684 * such private (since not exposed to userpace) objects as the atomic core and
685 * helpers already provide for connectors, planes and CRTCs.
687 * To make this easier on drivers the atomic core provides some support to track
688 * driver private state objects using struct &drm_private_obj, with the
689 * associated state struct &drm_private_state.
691 * Similar to userspace-exposed objects, private state structures can be
692 * acquired by calling drm_atomic_get_private_obj_state(). This also takes care
693 * of locking, hence drivers should not have a need to call drm_modeset_lock()
694 * directly. Sequence of the actual hardware state commit is not handled,
695 * drivers might need to keep track of struct drm_crtc_commit within subclassed
696 * structure of &drm_private_state as necessary, e.g. similar to
697 * &drm_plane_state.commit. See also &drm_atomic_state.fake_commit.
699 * All private state structures contained in a &drm_atomic_state update can be
700 * iterated using for_each_oldnew_private_obj_in_state(),
701 * for_each_new_private_obj_in_state() and for_each_old_private_obj_in_state().
702 * Drivers are recommended to wrap these for each type of driver private state
703 * object they have, filtering on &drm_private_obj.funcs using for_each_if(), at
704 * least if they want to iterate over all objects of a given type.
706 * An earlier way to handle driver private state was by subclassing struct
707 * &drm_atomic_state. But since that encourages non-standard ways to implement
708 * the check/commit split atomic requires (by using e.g. "check and rollback or
709 * commit instead" of "duplicate state, check, then either commit or release
710 * duplicated state) it is deprecated in favour of using &drm_private_state.
714 * drm_atomic_private_obj_init - initialize private object
715 * @dev: DRM device this object will be attached to
716 * @obj: private object
717 * @state: initial private object state
718 * @funcs: pointer to the struct of function pointers that identify the object
721 * Initialize the private object, which can be embedded into any
722 * driver private object that needs its own atomic state.
725 drm_atomic_private_obj_init(struct drm_device
*dev
,
726 struct drm_private_obj
*obj
,
727 struct drm_private_state
*state
,
728 const struct drm_private_state_funcs
*funcs
)
730 memset(obj
, 0, sizeof(*obj
));
732 drm_modeset_lock_init(&obj
->lock
);
736 list_add_tail(&obj
->head
, &dev
->mode_config
.privobj_list
);
738 EXPORT_SYMBOL(drm_atomic_private_obj_init
);
741 * drm_atomic_private_obj_fini - finalize private object
742 * @obj: private object
744 * Finalize the private object.
747 drm_atomic_private_obj_fini(struct drm_private_obj
*obj
)
749 list_del(&obj
->head
);
750 obj
->funcs
->atomic_destroy_state(obj
, obj
->state
);
751 drm_modeset_lock_fini(&obj
->lock
);
753 EXPORT_SYMBOL(drm_atomic_private_obj_fini
);
756 * drm_atomic_get_private_obj_state - get private object state
757 * @state: global atomic state
758 * @obj: private object to get the state for
760 * This function returns the private object state for the given private object,
761 * allocating the state if needed. It will also grab the relevant private
762 * object lock to make sure that the state is consistent.
766 * Either the allocated state or the error code encoded into a pointer.
768 struct drm_private_state
*
769 drm_atomic_get_private_obj_state(struct drm_atomic_state
*state
,
770 struct drm_private_obj
*obj
)
772 int index
, num_objs
, i
, ret
;
774 struct __drm_private_objs_state
*arr
;
775 struct drm_private_state
*obj_state
;
777 for (i
= 0; i
< state
->num_private_objs
; i
++)
778 if (obj
== state
->private_objs
[i
].ptr
)
779 return state
->private_objs
[i
].state
;
781 ret
= drm_modeset_lock(&obj
->lock
, state
->acquire_ctx
);
785 num_objs
= state
->num_private_objs
+ 1;
786 size
= sizeof(*state
->private_objs
) * num_objs
;
787 arr
= krealloc(state
->private_objs
, size
, GFP_KERNEL
);
789 return ERR_PTR(-ENOMEM
);
791 state
->private_objs
= arr
;
792 index
= state
->num_private_objs
;
793 memset(&state
->private_objs
[index
], 0, sizeof(*state
->private_objs
));
795 obj_state
= obj
->funcs
->atomic_duplicate_state(obj
);
797 return ERR_PTR(-ENOMEM
);
799 state
->private_objs
[index
].state
= obj_state
;
800 state
->private_objs
[index
].old_state
= obj
->state
;
801 state
->private_objs
[index
].new_state
= obj_state
;
802 state
->private_objs
[index
].ptr
= obj
;
803 obj_state
->state
= state
;
805 state
->num_private_objs
= num_objs
;
807 DRM_DEBUG_ATOMIC("Added new private object %p state %p to %p\n",
808 obj
, obj_state
, state
);
812 EXPORT_SYMBOL(drm_atomic_get_private_obj_state
);
815 * drm_atomic_get_old_private_obj_state
816 * @state: global atomic state object
817 * @obj: private_obj to grab
819 * This function returns the old private object state for the given private_obj,
820 * or NULL if the private_obj is not part of the global atomic state.
822 struct drm_private_state
*
823 drm_atomic_get_old_private_obj_state(struct drm_atomic_state
*state
,
824 struct drm_private_obj
*obj
)
828 for (i
= 0; i
< state
->num_private_objs
; i
++)
829 if (obj
== state
->private_objs
[i
].ptr
)
830 return state
->private_objs
[i
].old_state
;
834 EXPORT_SYMBOL(drm_atomic_get_old_private_obj_state
);
837 * drm_atomic_get_new_private_obj_state
838 * @state: global atomic state object
839 * @obj: private_obj to grab
841 * This function returns the new private object state for the given private_obj,
842 * or NULL if the private_obj is not part of the global atomic state.
844 struct drm_private_state
*
845 drm_atomic_get_new_private_obj_state(struct drm_atomic_state
*state
,
846 struct drm_private_obj
*obj
)
850 for (i
= 0; i
< state
->num_private_objs
; i
++)
851 if (obj
== state
->private_objs
[i
].ptr
)
852 return state
->private_objs
[i
].new_state
;
856 EXPORT_SYMBOL(drm_atomic_get_new_private_obj_state
);
859 * drm_atomic_get_old_connector_for_encoder - Get old connector for an encoder
860 * @state: Atomic state
861 * @encoder: The encoder to fetch the connector state for
863 * This function finds and returns the connector that was connected to @encoder
864 * as specified by the @state.
866 * If there is no connector in @state which previously had @encoder connected to
867 * it, this function will return NULL. While this may seem like an invalid use
868 * case, it is sometimes useful to differentiate commits which had no prior
869 * connectors attached to @encoder vs ones that did (and to inspect their
870 * state). This is especially true in enable hooks because the pipeline has
873 * Returns: The old connector connected to @encoder, or NULL if the encoder is
876 struct drm_connector
*
877 drm_atomic_get_old_connector_for_encoder(struct drm_atomic_state
*state
,
878 struct drm_encoder
*encoder
)
880 struct drm_connector_state
*conn_state
;
881 struct drm_connector
*connector
;
884 for_each_old_connector_in_state(state
, connector
, conn_state
, i
) {
885 if (conn_state
->best_encoder
== encoder
)
891 EXPORT_SYMBOL(drm_atomic_get_old_connector_for_encoder
);
894 * drm_atomic_get_new_connector_for_encoder - Get new connector for an encoder
895 * @state: Atomic state
896 * @encoder: The encoder to fetch the connector state for
898 * This function finds and returns the connector that will be connected to
899 * @encoder as specified by the @state.
901 * If there is no connector in @state which will have @encoder connected to it,
902 * this function will return NULL. While this may seem like an invalid use case,
903 * it is sometimes useful to differentiate commits which have no connectors
904 * attached to @encoder vs ones that do (and to inspect their state). This is
905 * especially true in disable hooks because the pipeline will change.
907 * Returns: The new connector connected to @encoder, or NULL if the encoder is
910 struct drm_connector
*
911 drm_atomic_get_new_connector_for_encoder(struct drm_atomic_state
*state
,
912 struct drm_encoder
*encoder
)
914 struct drm_connector_state
*conn_state
;
915 struct drm_connector
*connector
;
918 for_each_new_connector_in_state(state
, connector
, conn_state
, i
) {
919 if (conn_state
->best_encoder
== encoder
)
925 EXPORT_SYMBOL(drm_atomic_get_new_connector_for_encoder
);
928 * drm_atomic_get_connector_state - get connector state
929 * @state: global atomic state object
930 * @connector: connector to get state object for
932 * This function returns the connector state for the given connector,
933 * allocating it if needed. It will also grab the relevant connector lock to
934 * make sure that the state is consistent.
938 * Either the allocated state or the error code encoded into the pointer. When
939 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
940 * entire atomic sequence must be restarted. All other errors are fatal.
942 struct drm_connector_state
*
943 drm_atomic_get_connector_state(struct drm_atomic_state
*state
,
944 struct drm_connector
*connector
)
947 struct drm_mode_config
*config
= &connector
->dev
->mode_config
;
948 struct drm_connector_state
*connector_state
;
950 WARN_ON(!state
->acquire_ctx
);
952 ret
= drm_modeset_lock(&config
->connection_mutex
, state
->acquire_ctx
);
956 index
= drm_connector_index(connector
);
958 if (index
>= state
->num_connector
) {
959 struct __drm_connnectors_state
*c
;
960 int alloc
= max(index
+ 1, config
->num_connector
);
962 c
= krealloc(state
->connectors
, alloc
* sizeof(*state
->connectors
), GFP_KERNEL
);
964 return ERR_PTR(-ENOMEM
);
966 state
->connectors
= c
;
967 memset(&state
->connectors
[state
->num_connector
], 0,
968 sizeof(*state
->connectors
) * (alloc
- state
->num_connector
));
970 state
->num_connector
= alloc
;
973 if (state
->connectors
[index
].state
)
974 return state
->connectors
[index
].state
;
976 connector_state
= connector
->funcs
->atomic_duplicate_state(connector
);
977 if (!connector_state
)
978 return ERR_PTR(-ENOMEM
);
980 drm_connector_get(connector
);
981 state
->connectors
[index
].state
= connector_state
;
982 state
->connectors
[index
].old_state
= connector
->state
;
983 state
->connectors
[index
].new_state
= connector_state
;
984 state
->connectors
[index
].ptr
= connector
;
985 connector_state
->state
= state
;
987 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d:%s] %p state to %p\n",
988 connector
->base
.id
, connector
->name
,
989 connector_state
, state
);
991 if (connector_state
->crtc
) {
992 struct drm_crtc_state
*crtc_state
;
994 crtc_state
= drm_atomic_get_crtc_state(state
,
995 connector_state
->crtc
);
996 if (IS_ERR(crtc_state
))
997 return ERR_CAST(crtc_state
);
1000 return connector_state
;
1002 EXPORT_SYMBOL(drm_atomic_get_connector_state
);
1004 static void drm_atomic_connector_print_state(struct drm_printer
*p
,
1005 const struct drm_connector_state
*state
)
1007 struct drm_connector
*connector
= state
->connector
;
1009 drm_printf(p
, "connector[%u]: %s\n", connector
->base
.id
, connector
->name
);
1010 drm_printf(p
, "\tcrtc=%s\n", state
->crtc
? state
->crtc
->name
: "(null)");
1011 drm_printf(p
, "\tself_refresh_aware=%d\n", state
->self_refresh_aware
);
1013 if (connector
->connector_type
== DRM_MODE_CONNECTOR_WRITEBACK
)
1014 if (state
->writeback_job
&& state
->writeback_job
->fb
)
1015 drm_printf(p
, "\tfb=%d\n", state
->writeback_job
->fb
->base
.id
);
1017 if (connector
->funcs
->atomic_print_state
)
1018 connector
->funcs
->atomic_print_state(p
, state
);
1022 * drm_atomic_get_bridge_state - get bridge state
1023 * @state: global atomic state object
1024 * @bridge: bridge to get state object for
1026 * This function returns the bridge state for the given bridge, allocating it
1027 * if needed. It will also grab the relevant bridge lock to make sure that the
1028 * state is consistent.
1032 * Either the allocated state or the error code encoded into the pointer. When
1033 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
1034 * entire atomic sequence must be restarted.
1036 struct drm_bridge_state
*
1037 drm_atomic_get_bridge_state(struct drm_atomic_state
*state
,
1038 struct drm_bridge
*bridge
)
1040 struct drm_private_state
*obj_state
;
1042 obj_state
= drm_atomic_get_private_obj_state(state
, &bridge
->base
);
1043 if (IS_ERR(obj_state
))
1044 return ERR_CAST(obj_state
);
1046 return drm_priv_to_bridge_state(obj_state
);
1048 EXPORT_SYMBOL(drm_atomic_get_bridge_state
);
1051 * drm_atomic_get_old_bridge_state - get old bridge state, if it exists
1052 * @state: global atomic state object
1053 * @bridge: bridge to grab
1055 * This function returns the old bridge state for the given bridge, or NULL if
1056 * the bridge is not part of the global atomic state.
1058 struct drm_bridge_state
*
1059 drm_atomic_get_old_bridge_state(struct drm_atomic_state
*state
,
1060 struct drm_bridge
*bridge
)
1062 struct drm_private_state
*obj_state
;
1064 obj_state
= drm_atomic_get_old_private_obj_state(state
, &bridge
->base
);
1068 return drm_priv_to_bridge_state(obj_state
);
1070 EXPORT_SYMBOL(drm_atomic_get_old_bridge_state
);
1073 * drm_atomic_get_new_bridge_state - get new bridge state, if it exists
1074 * @state: global atomic state object
1075 * @bridge: bridge to grab
1077 * This function returns the new bridge state for the given bridge, or NULL if
1078 * the bridge is not part of the global atomic state.
1080 struct drm_bridge_state
*
1081 drm_atomic_get_new_bridge_state(struct drm_atomic_state
*state
,
1082 struct drm_bridge
*bridge
)
1084 struct drm_private_state
*obj_state
;
1086 obj_state
= drm_atomic_get_new_private_obj_state(state
, &bridge
->base
);
1090 return drm_priv_to_bridge_state(obj_state
);
1092 EXPORT_SYMBOL(drm_atomic_get_new_bridge_state
);
1095 * drm_atomic_add_encoder_bridges - add bridges attached to an encoder
1096 * @state: atomic state
1097 * @encoder: DRM encoder
1099 * This function adds all bridges attached to @encoder. This is needed to add
1100 * bridge states to @state and make them available when
1101 * &drm_bridge_funcs.atomic_check(), &drm_bridge_funcs.atomic_pre_enable(),
1102 * &drm_bridge_funcs.atomic_enable(),
1103 * &drm_bridge_funcs.atomic_disable_post_disable() are called.
1106 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1107 * then the w/w mutex code has detected a deadlock and the entire atomic
1108 * sequence must be restarted. All other errors are fatal.
1111 drm_atomic_add_encoder_bridges(struct drm_atomic_state
*state
,
1112 struct drm_encoder
*encoder
)
1114 struct drm_bridge_state
*bridge_state
;
1115 struct drm_bridge
*bridge
;
1120 DRM_DEBUG_ATOMIC("Adding all bridges for [encoder:%d:%s] to %p\n",
1121 encoder
->base
.id
, encoder
->name
, state
);
1123 drm_for_each_bridge_in_chain(encoder
, bridge
) {
1124 /* Skip bridges that don't implement the atomic state hooks. */
1125 if (!bridge
->funcs
->atomic_duplicate_state
)
1128 bridge_state
= drm_atomic_get_bridge_state(state
, bridge
);
1129 if (IS_ERR(bridge_state
))
1130 return PTR_ERR(bridge_state
);
1135 EXPORT_SYMBOL(drm_atomic_add_encoder_bridges
);
1138 * drm_atomic_add_affected_connectors - add connectors for CRTC
1139 * @state: atomic state
1142 * This function walks the current configuration and adds all connectors
1143 * currently using @crtc to the atomic configuration @state. Note that this
1144 * function must acquire the connection mutex. This can potentially cause
1145 * unneeded seralization if the update is just for the planes on one CRTC. Hence
1146 * drivers and helpers should only call this when really needed (e.g. when a
1147 * full modeset needs to happen due to some change).
1150 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1151 * then the w/w mutex code has detected a deadlock and the entire atomic
1152 * sequence must be restarted. All other errors are fatal.
1155 drm_atomic_add_affected_connectors(struct drm_atomic_state
*state
,
1156 struct drm_crtc
*crtc
)
1158 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1159 struct drm_connector
*connector
;
1160 struct drm_connector_state
*conn_state
;
1161 struct drm_connector_list_iter conn_iter
;
1162 struct drm_crtc_state
*crtc_state
;
1165 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
1166 if (IS_ERR(crtc_state
))
1167 return PTR_ERR(crtc_state
);
1169 ret
= drm_modeset_lock(&config
->connection_mutex
, state
->acquire_ctx
);
1173 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %p\n",
1174 crtc
->base
.id
, crtc
->name
, state
);
1177 * Changed connectors are already in @state, so only need to look
1178 * at the connector_mask in crtc_state.
1180 drm_connector_list_iter_begin(state
->dev
, &conn_iter
);
1181 drm_for_each_connector_iter(connector
, &conn_iter
) {
1182 if (!(crtc_state
->connector_mask
& drm_connector_mask(connector
)))
1185 conn_state
= drm_atomic_get_connector_state(state
, connector
);
1186 if (IS_ERR(conn_state
)) {
1187 drm_connector_list_iter_end(&conn_iter
);
1188 return PTR_ERR(conn_state
);
1191 drm_connector_list_iter_end(&conn_iter
);
1195 EXPORT_SYMBOL(drm_atomic_add_affected_connectors
);
1198 * drm_atomic_add_affected_planes - add planes for CRTC
1199 * @state: atomic state
1202 * This function walks the current configuration and adds all planes
1203 * currently used by @crtc to the atomic configuration @state. This is useful
1204 * when an atomic commit also needs to check all currently enabled plane on
1205 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1206 * to avoid special code to force-enable all planes.
1208 * Since acquiring a plane state will always also acquire the w/w mutex of the
1209 * current CRTC for that plane (if there is any) adding all the plane states for
1210 * a CRTC will not reduce parallism of atomic updates.
1213 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1214 * then the w/w mutex code has detected a deadlock and the entire atomic
1215 * sequence must be restarted. All other errors are fatal.
1218 drm_atomic_add_affected_planes(struct drm_atomic_state
*state
,
1219 struct drm_crtc
*crtc
)
1221 const struct drm_crtc_state
*old_crtc_state
=
1222 drm_atomic_get_old_crtc_state(state
, crtc
);
1223 struct drm_plane
*plane
;
1225 WARN_ON(!drm_atomic_get_new_crtc_state(state
, crtc
));
1227 DRM_DEBUG_ATOMIC("Adding all current planes for [CRTC:%d:%s] to %p\n",
1228 crtc
->base
.id
, crtc
->name
, state
);
1230 drm_for_each_plane_mask(plane
, state
->dev
, old_crtc_state
->plane_mask
) {
1231 struct drm_plane_state
*plane_state
=
1232 drm_atomic_get_plane_state(state
, plane
);
1234 if (IS_ERR(plane_state
))
1235 return PTR_ERR(plane_state
);
1239 EXPORT_SYMBOL(drm_atomic_add_affected_planes
);
1242 * drm_atomic_check_only - check whether a given config would work
1243 * @state: atomic configuration to check
1245 * Note that this function can return -EDEADLK if the driver needed to acquire
1246 * more locks but encountered a deadlock. The caller must then do the usual w/w
1247 * backoff dance and restart. All other errors are fatal.
1250 * 0 on success, negative error code on failure.
1252 int drm_atomic_check_only(struct drm_atomic_state
*state
)
1254 struct drm_device
*dev
= state
->dev
;
1255 struct drm_mode_config
*config
= &dev
->mode_config
;
1256 struct drm_plane
*plane
;
1257 struct drm_plane_state
*old_plane_state
;
1258 struct drm_plane_state
*new_plane_state
;
1259 struct drm_crtc
*crtc
;
1260 struct drm_crtc_state
*old_crtc_state
;
1261 struct drm_crtc_state
*new_crtc_state
;
1262 struct drm_connector
*conn
;
1263 struct drm_connector_state
*conn_state
;
1266 DRM_DEBUG_ATOMIC("checking %p\n", state
);
1268 for_each_oldnew_plane_in_state(state
, plane
, old_plane_state
, new_plane_state
, i
) {
1269 ret
= drm_atomic_plane_check(old_plane_state
, new_plane_state
);
1271 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic core check failed\n",
1272 plane
->base
.id
, plane
->name
);
1277 for_each_oldnew_crtc_in_state(state
, crtc
, old_crtc_state
, new_crtc_state
, i
) {
1278 ret
= drm_atomic_crtc_check(old_crtc_state
, new_crtc_state
);
1280 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic core check failed\n",
1281 crtc
->base
.id
, crtc
->name
);
1286 for_each_new_connector_in_state(state
, conn
, conn_state
, i
) {
1287 ret
= drm_atomic_connector_check(conn
, conn_state
);
1289 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] atomic core check failed\n",
1290 conn
->base
.id
, conn
->name
);
1295 if (config
->funcs
->atomic_check
) {
1296 ret
= config
->funcs
->atomic_check(state
->dev
, state
);
1299 DRM_DEBUG_ATOMIC("atomic driver check for %p failed: %d\n",
1305 if (!state
->allow_modeset
) {
1306 for_each_new_crtc_in_state(state
, crtc
, new_crtc_state
, i
) {
1307 if (drm_atomic_crtc_needs_modeset(new_crtc_state
)) {
1308 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requires full modeset\n",
1309 crtc
->base
.id
, crtc
->name
);
1317 EXPORT_SYMBOL(drm_atomic_check_only
);
1320 * drm_atomic_commit - commit configuration atomically
1321 * @state: atomic configuration to check
1323 * Note that this function can return -EDEADLK if the driver needed to acquire
1324 * more locks but encountered a deadlock. The caller must then do the usual w/w
1325 * backoff dance and restart. All other errors are fatal.
1327 * This function will take its own reference on @state.
1328 * Callers should always release their reference with drm_atomic_state_put().
1331 * 0 on success, negative error code on failure.
1333 int drm_atomic_commit(struct drm_atomic_state
*state
)
1335 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1338 ret
= drm_atomic_check_only(state
);
1342 DRM_DEBUG_ATOMIC("committing %p\n", state
);
1344 return config
->funcs
->atomic_commit(state
->dev
, state
, false);
1346 EXPORT_SYMBOL(drm_atomic_commit
);
1349 * drm_atomic_nonblocking_commit - atomic nonblocking commit
1350 * @state: atomic configuration to check
1352 * Note that this function can return -EDEADLK if the driver needed to acquire
1353 * more locks but encountered a deadlock. The caller must then do the usual w/w
1354 * backoff dance and restart. All other errors are fatal.
1356 * This function will take its own reference on @state.
1357 * Callers should always release their reference with drm_atomic_state_put().
1360 * 0 on success, negative error code on failure.
1362 int drm_atomic_nonblocking_commit(struct drm_atomic_state
*state
)
1364 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1367 ret
= drm_atomic_check_only(state
);
1371 DRM_DEBUG_ATOMIC("committing %p nonblocking\n", state
);
1373 return config
->funcs
->atomic_commit(state
->dev
, state
, true);
1375 EXPORT_SYMBOL(drm_atomic_nonblocking_commit
);
1377 /* just used from drm-client and atomic-helper: */
1378 int __drm_atomic_helper_disable_plane(struct drm_plane
*plane
,
1379 struct drm_plane_state
*plane_state
)
1383 ret
= drm_atomic_set_crtc_for_plane(plane_state
, NULL
);
1387 drm_atomic_set_fb_for_plane(plane_state
, NULL
);
1388 plane_state
->crtc_x
= 0;
1389 plane_state
->crtc_y
= 0;
1390 plane_state
->crtc_w
= 0;
1391 plane_state
->crtc_h
= 0;
1392 plane_state
->src_x
= 0;
1393 plane_state
->src_y
= 0;
1394 plane_state
->src_w
= 0;
1395 plane_state
->src_h
= 0;
1399 EXPORT_SYMBOL(__drm_atomic_helper_disable_plane
);
1401 static int update_output_state(struct drm_atomic_state
*state
,
1402 struct drm_mode_set
*set
)
1404 struct drm_device
*dev
= set
->crtc
->dev
;
1405 struct drm_crtc
*crtc
;
1406 struct drm_crtc_state
*new_crtc_state
;
1407 struct drm_connector
*connector
;
1408 struct drm_connector_state
*new_conn_state
;
1411 ret
= drm_modeset_lock(&dev
->mode_config
.connection_mutex
,
1412 state
->acquire_ctx
);
1416 /* First disable all connectors on the target crtc. */
1417 ret
= drm_atomic_add_affected_connectors(state
, set
->crtc
);
1421 for_each_new_connector_in_state(state
, connector
, new_conn_state
, i
) {
1422 if (new_conn_state
->crtc
== set
->crtc
) {
1423 ret
= drm_atomic_set_crtc_for_connector(new_conn_state
,
1428 /* Make sure legacy setCrtc always re-trains */
1429 new_conn_state
->link_status
= DRM_LINK_STATUS_GOOD
;
1433 /* Then set all connectors from set->connectors on the target crtc */
1434 for (i
= 0; i
< set
->num_connectors
; i
++) {
1435 new_conn_state
= drm_atomic_get_connector_state(state
,
1436 set
->connectors
[i
]);
1437 if (IS_ERR(new_conn_state
))
1438 return PTR_ERR(new_conn_state
);
1440 ret
= drm_atomic_set_crtc_for_connector(new_conn_state
,
1446 for_each_new_crtc_in_state(state
, crtc
, new_crtc_state
, i
) {
1448 * Don't update ->enable for the CRTC in the set_config request,
1449 * since a mismatch would indicate a bug in the upper layers.
1450 * The actual modeset code later on will catch any
1451 * inconsistencies here.
1453 if (crtc
== set
->crtc
)
1456 if (!new_crtc_state
->connector_mask
) {
1457 ret
= drm_atomic_set_mode_prop_for_crtc(new_crtc_state
,
1462 new_crtc_state
->active
= false;
1469 /* just used from drm-client and atomic-helper: */
1470 int __drm_atomic_helper_set_config(struct drm_mode_set
*set
,
1471 struct drm_atomic_state
*state
)
1473 struct drm_crtc_state
*crtc_state
;
1474 struct drm_plane_state
*primary_state
;
1475 struct drm_crtc
*crtc
= set
->crtc
;
1476 int hdisplay
, vdisplay
;
1479 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
1480 if (IS_ERR(crtc_state
))
1481 return PTR_ERR(crtc_state
);
1483 primary_state
= drm_atomic_get_plane_state(state
, crtc
->primary
);
1484 if (IS_ERR(primary_state
))
1485 return PTR_ERR(primary_state
);
1489 WARN_ON(set
->num_connectors
);
1491 ret
= drm_atomic_set_mode_for_crtc(crtc_state
, NULL
);
1495 crtc_state
->active
= false;
1497 ret
= drm_atomic_set_crtc_for_plane(primary_state
, NULL
);
1501 drm_atomic_set_fb_for_plane(primary_state
, NULL
);
1507 WARN_ON(!set
->num_connectors
);
1509 ret
= drm_atomic_set_mode_for_crtc(crtc_state
, set
->mode
);
1513 crtc_state
->active
= true;
1515 ret
= drm_atomic_set_crtc_for_plane(primary_state
, crtc
);
1519 drm_mode_get_hv_timing(set
->mode
, &hdisplay
, &vdisplay
);
1521 drm_atomic_set_fb_for_plane(primary_state
, set
->fb
);
1522 primary_state
->crtc_x
= 0;
1523 primary_state
->crtc_y
= 0;
1524 primary_state
->crtc_w
= hdisplay
;
1525 primary_state
->crtc_h
= vdisplay
;
1526 primary_state
->src_x
= set
->x
<< 16;
1527 primary_state
->src_y
= set
->y
<< 16;
1528 if (drm_rotation_90_or_270(primary_state
->rotation
)) {
1529 primary_state
->src_w
= vdisplay
<< 16;
1530 primary_state
->src_h
= hdisplay
<< 16;
1532 primary_state
->src_w
= hdisplay
<< 16;
1533 primary_state
->src_h
= vdisplay
<< 16;
1537 ret
= update_output_state(state
, set
);
1543 EXPORT_SYMBOL(__drm_atomic_helper_set_config
);
1545 void drm_atomic_print_state(const struct drm_atomic_state
*state
)
1547 struct drm_printer p
= drm_info_printer(state
->dev
->dev
);
1548 struct drm_plane
*plane
;
1549 struct drm_plane_state
*plane_state
;
1550 struct drm_crtc
*crtc
;
1551 struct drm_crtc_state
*crtc_state
;
1552 struct drm_connector
*connector
;
1553 struct drm_connector_state
*connector_state
;
1556 DRM_DEBUG_ATOMIC("checking %p\n", state
);
1558 for_each_new_plane_in_state(state
, plane
, plane_state
, i
)
1559 drm_atomic_plane_print_state(&p
, plane_state
);
1561 for_each_new_crtc_in_state(state
, crtc
, crtc_state
, i
)
1562 drm_atomic_crtc_print_state(&p
, crtc_state
);
1564 for_each_new_connector_in_state(state
, connector
, connector_state
, i
)
1565 drm_atomic_connector_print_state(&p
, connector_state
);
1568 static void __drm_state_dump(struct drm_device
*dev
, struct drm_printer
*p
,
1571 struct drm_mode_config
*config
= &dev
->mode_config
;
1572 struct drm_plane
*plane
;
1573 struct drm_crtc
*crtc
;
1574 struct drm_connector
*connector
;
1575 struct drm_connector_list_iter conn_iter
;
1577 if (!drm_drv_uses_atomic_modeset(dev
))
1580 list_for_each_entry(plane
, &config
->plane_list
, head
) {
1582 drm_modeset_lock(&plane
->mutex
, NULL
);
1583 drm_atomic_plane_print_state(p
, plane
->state
);
1585 drm_modeset_unlock(&plane
->mutex
);
1588 list_for_each_entry(crtc
, &config
->crtc_list
, head
) {
1590 drm_modeset_lock(&crtc
->mutex
, NULL
);
1591 drm_atomic_crtc_print_state(p
, crtc
->state
);
1593 drm_modeset_unlock(&crtc
->mutex
);
1596 drm_connector_list_iter_begin(dev
, &conn_iter
);
1598 drm_modeset_lock(&dev
->mode_config
.connection_mutex
, NULL
);
1599 drm_for_each_connector_iter(connector
, &conn_iter
)
1600 drm_atomic_connector_print_state(p
, connector
->state
);
1602 drm_modeset_unlock(&dev
->mode_config
.connection_mutex
);
1603 drm_connector_list_iter_end(&conn_iter
);
1607 * drm_state_dump - dump entire device atomic state
1608 * @dev: the drm device
1609 * @p: where to print the state to
1611 * Just for debugging. Drivers might want an option to dump state
1612 * to dmesg in case of error irq's. (Hint, you probably want to
1615 * The caller must drm_modeset_lock_all(), or if this is called
1616 * from error irq handler, it should not be enabled by default.
1617 * (Ie. if you are debugging errors you might not care that this
1618 * is racey. But calling this without all modeset locks held is
1619 * not inherently safe.)
1621 void drm_state_dump(struct drm_device
*dev
, struct drm_printer
*p
)
1623 __drm_state_dump(dev
, p
, false);
1625 EXPORT_SYMBOL(drm_state_dump
);
1627 #ifdef CONFIG_DEBUG_FS
1628 static int drm_state_info(struct seq_file
*m
, void *data
)
1630 struct drm_info_node
*node
= (struct drm_info_node
*) m
->private;
1631 struct drm_device
*dev
= node
->minor
->dev
;
1632 struct drm_printer p
= drm_seq_file_printer(m
);
1634 __drm_state_dump(dev
, &p
, true);
1639 /* any use in debugfs files to dump individual planes/crtc/etc? */
1640 static const struct drm_info_list drm_atomic_debugfs_list
[] = {
1641 {"state", drm_state_info
, 0},
1644 void drm_atomic_debugfs_init(struct drm_minor
*minor
)
1646 drm_debugfs_create_files(drm_atomic_debugfs_list
,
1647 ARRAY_SIZE(drm_atomic_debugfs_list
),
1648 minor
->debugfs_root
, minor
);