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
;
579 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] invalid pixel format %s, modifier 0x%llx\n",
580 plane
->base
.id
, plane
->name
,
581 drm_get_format_name(fb
->format
->format
,
587 /* Give drivers some help against integer overflows */
588 if (new_plane_state
->crtc_w
> INT_MAX
||
589 new_plane_state
->crtc_x
> INT_MAX
- (int32_t) new_plane_state
->crtc_w
||
590 new_plane_state
->crtc_h
> INT_MAX
||
591 new_plane_state
->crtc_y
> INT_MAX
- (int32_t) new_plane_state
->crtc_h
) {
592 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] invalid CRTC coordinates %ux%u+%d+%d\n",
593 plane
->base
.id
, plane
->name
,
594 new_plane_state
->crtc_w
, new_plane_state
->crtc_h
,
595 new_plane_state
->crtc_x
, new_plane_state
->crtc_y
);
599 fb_width
= fb
->width
<< 16;
600 fb_height
= fb
->height
<< 16;
602 /* Make sure source coordinates are inside the fb. */
603 if (new_plane_state
->src_w
> fb_width
||
604 new_plane_state
->src_x
> fb_width
- new_plane_state
->src_w
||
605 new_plane_state
->src_h
> fb_height
||
606 new_plane_state
->src_y
> fb_height
- new_plane_state
->src_h
) {
607 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] invalid source coordinates "
608 "%u.%06ux%u.%06u+%u.%06u+%u.%06u (fb %ux%u)\n",
609 plane
->base
.id
, plane
->name
,
610 new_plane_state
->src_w
>> 16,
611 ((new_plane_state
->src_w
& 0xffff) * 15625) >> 10,
612 new_plane_state
->src_h
>> 16,
613 ((new_plane_state
->src_h
& 0xffff) * 15625) >> 10,
614 new_plane_state
->src_x
>> 16,
615 ((new_plane_state
->src_x
& 0xffff) * 15625) >> 10,
616 new_plane_state
->src_y
>> 16,
617 ((new_plane_state
->src_y
& 0xffff) * 15625) >> 10,
618 fb
->width
, fb
->height
);
622 clips
= drm_plane_get_damage_clips(new_plane_state
);
623 num_clips
= drm_plane_get_damage_clips_count(new_plane_state
);
625 /* Make sure damage clips are valid and inside the fb. */
626 while (num_clips
> 0) {
627 if (clips
->x1
>= clips
->x2
||
628 clips
->y1
>= clips
->y2
||
631 clips
->x2
> fb_width
||
632 clips
->y2
> fb_height
) {
633 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] invalid damage clip %d %d %d %d\n",
634 plane
->base
.id
, plane
->name
, clips
->x1
,
635 clips
->y1
, clips
->x2
, clips
->y2
);
642 if (plane_switching_crtc(old_plane_state
, new_plane_state
)) {
643 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] switching CRTC directly\n",
644 plane
->base
.id
, plane
->name
);
651 static void drm_atomic_plane_print_state(struct drm_printer
*p
,
652 const struct drm_plane_state
*state
)
654 struct drm_plane
*plane
= state
->plane
;
655 struct drm_rect src
= drm_plane_state_src(state
);
656 struct drm_rect dest
= drm_plane_state_dest(state
);
658 drm_printf(p
, "plane[%u]: %s\n", plane
->base
.id
, plane
->name
);
659 drm_printf(p
, "\tcrtc=%s\n", state
->crtc
? state
->crtc
->name
: "(null)");
660 drm_printf(p
, "\tfb=%u\n", state
->fb
? state
->fb
->base
.id
: 0);
662 drm_framebuffer_print_info(p
, 2, state
->fb
);
663 drm_printf(p
, "\tcrtc-pos=" DRM_RECT_FMT
"\n", DRM_RECT_ARG(&dest
));
664 drm_printf(p
, "\tsrc-pos=" DRM_RECT_FP_FMT
"\n", DRM_RECT_FP_ARG(&src
));
665 drm_printf(p
, "\trotation=%x\n", state
->rotation
);
666 drm_printf(p
, "\tnormalized-zpos=%x\n", state
->normalized_zpos
);
667 drm_printf(p
, "\tcolor-encoding=%s\n",
668 drm_get_color_encoding_name(state
->color_encoding
));
669 drm_printf(p
, "\tcolor-range=%s\n",
670 drm_get_color_range_name(state
->color_range
));
672 if (plane
->funcs
->atomic_print_state
)
673 plane
->funcs
->atomic_print_state(p
, state
);
677 * DOC: handling driver private state
679 * Very often the DRM objects exposed to userspace in the atomic modeset api
680 * (&drm_connector, &drm_crtc and &drm_plane) do not map neatly to the
681 * underlying hardware. Especially for any kind of shared resources (e.g. shared
682 * clocks, scaler units, bandwidth and fifo limits shared among a group of
683 * planes or CRTCs, and so on) it makes sense to model these as independent
684 * objects. Drivers then need to do similar state tracking and commit ordering for
685 * such private (since not exposed to userpace) objects as the atomic core and
686 * helpers already provide for connectors, planes and CRTCs.
688 * To make this easier on drivers the atomic core provides some support to track
689 * driver private state objects using struct &drm_private_obj, with the
690 * associated state struct &drm_private_state.
692 * Similar to userspace-exposed objects, private state structures can be
693 * acquired by calling drm_atomic_get_private_obj_state(). This also takes care
694 * of locking, hence drivers should not have a need to call drm_modeset_lock()
695 * directly. Sequence of the actual hardware state commit is not handled,
696 * drivers might need to keep track of struct drm_crtc_commit within subclassed
697 * structure of &drm_private_state as necessary, e.g. similar to
698 * &drm_plane_state.commit. See also &drm_atomic_state.fake_commit.
700 * All private state structures contained in a &drm_atomic_state update can be
701 * iterated using for_each_oldnew_private_obj_in_state(),
702 * for_each_new_private_obj_in_state() and for_each_old_private_obj_in_state().
703 * Drivers are recommended to wrap these for each type of driver private state
704 * object they have, filtering on &drm_private_obj.funcs using for_each_if(), at
705 * least if they want to iterate over all objects of a given type.
707 * An earlier way to handle driver private state was by subclassing struct
708 * &drm_atomic_state. But since that encourages non-standard ways to implement
709 * the check/commit split atomic requires (by using e.g. "check and rollback or
710 * commit instead" of "duplicate state, check, then either commit or release
711 * duplicated state) it is deprecated in favour of using &drm_private_state.
715 * drm_atomic_private_obj_init - initialize private object
716 * @dev: DRM device this object will be attached to
717 * @obj: private object
718 * @state: initial private object state
719 * @funcs: pointer to the struct of function pointers that identify the object
722 * Initialize the private object, which can be embedded into any
723 * driver private object that needs its own atomic state.
726 drm_atomic_private_obj_init(struct drm_device
*dev
,
727 struct drm_private_obj
*obj
,
728 struct drm_private_state
*state
,
729 const struct drm_private_state_funcs
*funcs
)
731 memset(obj
, 0, sizeof(*obj
));
733 drm_modeset_lock_init(&obj
->lock
);
737 list_add_tail(&obj
->head
, &dev
->mode_config
.privobj_list
);
739 EXPORT_SYMBOL(drm_atomic_private_obj_init
);
742 * drm_atomic_private_obj_fini - finalize private object
743 * @obj: private object
745 * Finalize the private object.
748 drm_atomic_private_obj_fini(struct drm_private_obj
*obj
)
750 list_del(&obj
->head
);
751 obj
->funcs
->atomic_destroy_state(obj
, obj
->state
);
752 drm_modeset_lock_fini(&obj
->lock
);
754 EXPORT_SYMBOL(drm_atomic_private_obj_fini
);
757 * drm_atomic_get_private_obj_state - get private object state
758 * @state: global atomic state
759 * @obj: private object to get the state for
761 * This function returns the private object state for the given private object,
762 * allocating the state if needed. It will also grab the relevant private
763 * object lock to make sure that the state is consistent.
767 * Either the allocated state or the error code encoded into a pointer.
769 struct drm_private_state
*
770 drm_atomic_get_private_obj_state(struct drm_atomic_state
*state
,
771 struct drm_private_obj
*obj
)
773 int index
, num_objs
, i
, ret
;
775 struct __drm_private_objs_state
*arr
;
776 struct drm_private_state
*obj_state
;
778 for (i
= 0; i
< state
->num_private_objs
; i
++)
779 if (obj
== state
->private_objs
[i
].ptr
)
780 return state
->private_objs
[i
].state
;
782 ret
= drm_modeset_lock(&obj
->lock
, state
->acquire_ctx
);
786 num_objs
= state
->num_private_objs
+ 1;
787 size
= sizeof(*state
->private_objs
) * num_objs
;
788 arr
= krealloc(state
->private_objs
, size
, GFP_KERNEL
);
790 return ERR_PTR(-ENOMEM
);
792 state
->private_objs
= arr
;
793 index
= state
->num_private_objs
;
794 memset(&state
->private_objs
[index
], 0, sizeof(*state
->private_objs
));
796 obj_state
= obj
->funcs
->atomic_duplicate_state(obj
);
798 return ERR_PTR(-ENOMEM
);
800 state
->private_objs
[index
].state
= obj_state
;
801 state
->private_objs
[index
].old_state
= obj
->state
;
802 state
->private_objs
[index
].new_state
= obj_state
;
803 state
->private_objs
[index
].ptr
= obj
;
804 obj_state
->state
= state
;
806 state
->num_private_objs
= num_objs
;
808 DRM_DEBUG_ATOMIC("Added new private object %p state %p to %p\n",
809 obj
, obj_state
, state
);
813 EXPORT_SYMBOL(drm_atomic_get_private_obj_state
);
816 * drm_atomic_get_old_private_obj_state
817 * @state: global atomic state object
818 * @obj: private_obj to grab
820 * This function returns the old private object state for the given private_obj,
821 * or NULL if the private_obj is not part of the global atomic state.
823 struct drm_private_state
*
824 drm_atomic_get_old_private_obj_state(struct drm_atomic_state
*state
,
825 struct drm_private_obj
*obj
)
829 for (i
= 0; i
< state
->num_private_objs
; i
++)
830 if (obj
== state
->private_objs
[i
].ptr
)
831 return state
->private_objs
[i
].old_state
;
835 EXPORT_SYMBOL(drm_atomic_get_old_private_obj_state
);
838 * drm_atomic_get_new_private_obj_state
839 * @state: global atomic state object
840 * @obj: private_obj to grab
842 * This function returns the new private object state for the given private_obj,
843 * or NULL if the private_obj is not part of the global atomic state.
845 struct drm_private_state
*
846 drm_atomic_get_new_private_obj_state(struct drm_atomic_state
*state
,
847 struct drm_private_obj
*obj
)
851 for (i
= 0; i
< state
->num_private_objs
; i
++)
852 if (obj
== state
->private_objs
[i
].ptr
)
853 return state
->private_objs
[i
].new_state
;
857 EXPORT_SYMBOL(drm_atomic_get_new_private_obj_state
);
860 * drm_atomic_get_old_connector_for_encoder - Get old connector for an encoder
861 * @state: Atomic state
862 * @encoder: The encoder to fetch the connector state for
864 * This function finds and returns the connector that was connected to @encoder
865 * as specified by the @state.
867 * If there is no connector in @state which previously had @encoder connected to
868 * it, this function will return NULL. While this may seem like an invalid use
869 * case, it is sometimes useful to differentiate commits which had no prior
870 * connectors attached to @encoder vs ones that did (and to inspect their
871 * state). This is especially true in enable hooks because the pipeline has
874 * Returns: The old connector connected to @encoder, or NULL if the encoder is
877 struct drm_connector
*
878 drm_atomic_get_old_connector_for_encoder(struct drm_atomic_state
*state
,
879 struct drm_encoder
*encoder
)
881 struct drm_connector_state
*conn_state
;
882 struct drm_connector
*connector
;
885 for_each_old_connector_in_state(state
, connector
, conn_state
, i
) {
886 if (conn_state
->best_encoder
== encoder
)
892 EXPORT_SYMBOL(drm_atomic_get_old_connector_for_encoder
);
895 * drm_atomic_get_new_connector_for_encoder - Get new connector for an encoder
896 * @state: Atomic state
897 * @encoder: The encoder to fetch the connector state for
899 * This function finds and returns the connector that will be connected to
900 * @encoder as specified by the @state.
902 * If there is no connector in @state which will have @encoder connected to it,
903 * this function will return NULL. While this may seem like an invalid use case,
904 * it is sometimes useful to differentiate commits which have no connectors
905 * attached to @encoder vs ones that do (and to inspect their state). This is
906 * especially true in disable hooks because the pipeline will change.
908 * Returns: The new connector connected to @encoder, or NULL if the encoder is
911 struct drm_connector
*
912 drm_atomic_get_new_connector_for_encoder(struct drm_atomic_state
*state
,
913 struct drm_encoder
*encoder
)
915 struct drm_connector_state
*conn_state
;
916 struct drm_connector
*connector
;
919 for_each_new_connector_in_state(state
, connector
, conn_state
, i
) {
920 if (conn_state
->best_encoder
== encoder
)
926 EXPORT_SYMBOL(drm_atomic_get_new_connector_for_encoder
);
929 * drm_atomic_get_connector_state - get connector state
930 * @state: global atomic state object
931 * @connector: connector to get state object for
933 * This function returns the connector state for the given connector,
934 * allocating it if needed. It will also grab the relevant connector lock to
935 * make sure that the state is consistent.
939 * Either the allocated state or the error code encoded into the pointer. When
940 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
941 * entire atomic sequence must be restarted. All other errors are fatal.
943 struct drm_connector_state
*
944 drm_atomic_get_connector_state(struct drm_atomic_state
*state
,
945 struct drm_connector
*connector
)
948 struct drm_mode_config
*config
= &connector
->dev
->mode_config
;
949 struct drm_connector_state
*connector_state
;
951 WARN_ON(!state
->acquire_ctx
);
953 ret
= drm_modeset_lock(&config
->connection_mutex
, state
->acquire_ctx
);
957 index
= drm_connector_index(connector
);
959 if (index
>= state
->num_connector
) {
960 struct __drm_connnectors_state
*c
;
961 int alloc
= max(index
+ 1, config
->num_connector
);
963 c
= krealloc(state
->connectors
, alloc
* sizeof(*state
->connectors
), GFP_KERNEL
);
965 return ERR_PTR(-ENOMEM
);
967 state
->connectors
= c
;
968 memset(&state
->connectors
[state
->num_connector
], 0,
969 sizeof(*state
->connectors
) * (alloc
- state
->num_connector
));
971 state
->num_connector
= alloc
;
974 if (state
->connectors
[index
].state
)
975 return state
->connectors
[index
].state
;
977 connector_state
= connector
->funcs
->atomic_duplicate_state(connector
);
978 if (!connector_state
)
979 return ERR_PTR(-ENOMEM
);
981 drm_connector_get(connector
);
982 state
->connectors
[index
].state
= connector_state
;
983 state
->connectors
[index
].old_state
= connector
->state
;
984 state
->connectors
[index
].new_state
= connector_state
;
985 state
->connectors
[index
].ptr
= connector
;
986 connector_state
->state
= state
;
988 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d:%s] %p state to %p\n",
989 connector
->base
.id
, connector
->name
,
990 connector_state
, state
);
992 if (connector_state
->crtc
) {
993 struct drm_crtc_state
*crtc_state
;
995 crtc_state
= drm_atomic_get_crtc_state(state
,
996 connector_state
->crtc
);
997 if (IS_ERR(crtc_state
))
998 return ERR_CAST(crtc_state
);
1001 return connector_state
;
1003 EXPORT_SYMBOL(drm_atomic_get_connector_state
);
1005 static void drm_atomic_connector_print_state(struct drm_printer
*p
,
1006 const struct drm_connector_state
*state
)
1008 struct drm_connector
*connector
= state
->connector
;
1010 drm_printf(p
, "connector[%u]: %s\n", connector
->base
.id
, connector
->name
);
1011 drm_printf(p
, "\tcrtc=%s\n", state
->crtc
? state
->crtc
->name
: "(null)");
1012 drm_printf(p
, "\tself_refresh_aware=%d\n", state
->self_refresh_aware
);
1014 if (connector
->connector_type
== DRM_MODE_CONNECTOR_WRITEBACK
)
1015 if (state
->writeback_job
&& state
->writeback_job
->fb
)
1016 drm_printf(p
, "\tfb=%d\n", state
->writeback_job
->fb
->base
.id
);
1018 if (connector
->funcs
->atomic_print_state
)
1019 connector
->funcs
->atomic_print_state(p
, state
);
1023 * drm_atomic_get_bridge_state - get bridge state
1024 * @state: global atomic state object
1025 * @bridge: bridge to get state object for
1027 * This function returns the bridge state for the given bridge, allocating it
1028 * if needed. It will also grab the relevant bridge lock to make sure that the
1029 * state is consistent.
1033 * Either the allocated state or the error code encoded into the pointer. When
1034 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
1035 * entire atomic sequence must be restarted.
1037 struct drm_bridge_state
*
1038 drm_atomic_get_bridge_state(struct drm_atomic_state
*state
,
1039 struct drm_bridge
*bridge
)
1041 struct drm_private_state
*obj_state
;
1043 obj_state
= drm_atomic_get_private_obj_state(state
, &bridge
->base
);
1044 if (IS_ERR(obj_state
))
1045 return ERR_CAST(obj_state
);
1047 return drm_priv_to_bridge_state(obj_state
);
1049 EXPORT_SYMBOL(drm_atomic_get_bridge_state
);
1052 * drm_atomic_get_old_bridge_state - get old bridge state, if it exists
1053 * @state: global atomic state object
1054 * @bridge: bridge to grab
1056 * This function returns the old bridge state for the given bridge, or NULL if
1057 * the bridge is not part of the global atomic state.
1059 struct drm_bridge_state
*
1060 drm_atomic_get_old_bridge_state(struct drm_atomic_state
*state
,
1061 struct drm_bridge
*bridge
)
1063 struct drm_private_state
*obj_state
;
1065 obj_state
= drm_atomic_get_old_private_obj_state(state
, &bridge
->base
);
1069 return drm_priv_to_bridge_state(obj_state
);
1071 EXPORT_SYMBOL(drm_atomic_get_old_bridge_state
);
1074 * drm_atomic_get_new_bridge_state - get new bridge state, if it exists
1075 * @state: global atomic state object
1076 * @bridge: bridge to grab
1078 * This function returns the new bridge state for the given bridge, or NULL if
1079 * the bridge is not part of the global atomic state.
1081 struct drm_bridge_state
*
1082 drm_atomic_get_new_bridge_state(struct drm_atomic_state
*state
,
1083 struct drm_bridge
*bridge
)
1085 struct drm_private_state
*obj_state
;
1087 obj_state
= drm_atomic_get_new_private_obj_state(state
, &bridge
->base
);
1091 return drm_priv_to_bridge_state(obj_state
);
1093 EXPORT_SYMBOL(drm_atomic_get_new_bridge_state
);
1096 * drm_atomic_add_encoder_bridges - add bridges attached to an encoder
1097 * @state: atomic state
1098 * @encoder: DRM encoder
1100 * This function adds all bridges attached to @encoder. This is needed to add
1101 * bridge states to @state and make them available when
1102 * &drm_bridge_funcs.atomic_check(), &drm_bridge_funcs.atomic_pre_enable(),
1103 * &drm_bridge_funcs.atomic_enable(),
1104 * &drm_bridge_funcs.atomic_disable_post_disable() are called.
1107 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1108 * then the w/w mutex code has detected a deadlock and the entire atomic
1109 * sequence must be restarted. All other errors are fatal.
1112 drm_atomic_add_encoder_bridges(struct drm_atomic_state
*state
,
1113 struct drm_encoder
*encoder
)
1115 struct drm_bridge_state
*bridge_state
;
1116 struct drm_bridge
*bridge
;
1121 DRM_DEBUG_ATOMIC("Adding all bridges for [encoder:%d:%s] to %p\n",
1122 encoder
->base
.id
, encoder
->name
, state
);
1124 drm_for_each_bridge_in_chain(encoder
, bridge
) {
1125 /* Skip bridges that don't implement the atomic state hooks. */
1126 if (!bridge
->funcs
->atomic_duplicate_state
)
1129 bridge_state
= drm_atomic_get_bridge_state(state
, bridge
);
1130 if (IS_ERR(bridge_state
))
1131 return PTR_ERR(bridge_state
);
1136 EXPORT_SYMBOL(drm_atomic_add_encoder_bridges
);
1139 * drm_atomic_add_affected_connectors - add connectors for CRTC
1140 * @state: atomic state
1143 * This function walks the current configuration and adds all connectors
1144 * currently using @crtc to the atomic configuration @state. Note that this
1145 * function must acquire the connection mutex. This can potentially cause
1146 * unneeded seralization if the update is just for the planes on one CRTC. Hence
1147 * drivers and helpers should only call this when really needed (e.g. when a
1148 * full modeset needs to happen due to some change).
1151 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1152 * then the w/w mutex code has detected a deadlock and the entire atomic
1153 * sequence must be restarted. All other errors are fatal.
1156 drm_atomic_add_affected_connectors(struct drm_atomic_state
*state
,
1157 struct drm_crtc
*crtc
)
1159 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1160 struct drm_connector
*connector
;
1161 struct drm_connector_state
*conn_state
;
1162 struct drm_connector_list_iter conn_iter
;
1163 struct drm_crtc_state
*crtc_state
;
1166 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
1167 if (IS_ERR(crtc_state
))
1168 return PTR_ERR(crtc_state
);
1170 ret
= drm_modeset_lock(&config
->connection_mutex
, state
->acquire_ctx
);
1174 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %p\n",
1175 crtc
->base
.id
, crtc
->name
, state
);
1178 * Changed connectors are already in @state, so only need to look
1179 * at the connector_mask in crtc_state.
1181 drm_connector_list_iter_begin(state
->dev
, &conn_iter
);
1182 drm_for_each_connector_iter(connector
, &conn_iter
) {
1183 if (!(crtc_state
->connector_mask
& drm_connector_mask(connector
)))
1186 conn_state
= drm_atomic_get_connector_state(state
, connector
);
1187 if (IS_ERR(conn_state
)) {
1188 drm_connector_list_iter_end(&conn_iter
);
1189 return PTR_ERR(conn_state
);
1192 drm_connector_list_iter_end(&conn_iter
);
1196 EXPORT_SYMBOL(drm_atomic_add_affected_connectors
);
1199 * drm_atomic_add_affected_planes - add planes for CRTC
1200 * @state: atomic state
1203 * This function walks the current configuration and adds all planes
1204 * currently used by @crtc to the atomic configuration @state. This is useful
1205 * when an atomic commit also needs to check all currently enabled plane on
1206 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1207 * to avoid special code to force-enable all planes.
1209 * Since acquiring a plane state will always also acquire the w/w mutex of the
1210 * current CRTC for that plane (if there is any) adding all the plane states for
1211 * a CRTC will not reduce parallism of atomic updates.
1214 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1215 * then the w/w mutex code has detected a deadlock and the entire atomic
1216 * sequence must be restarted. All other errors are fatal.
1219 drm_atomic_add_affected_planes(struct drm_atomic_state
*state
,
1220 struct drm_crtc
*crtc
)
1222 const struct drm_crtc_state
*old_crtc_state
=
1223 drm_atomic_get_old_crtc_state(state
, crtc
);
1224 struct drm_plane
*plane
;
1226 WARN_ON(!drm_atomic_get_new_crtc_state(state
, crtc
));
1228 DRM_DEBUG_ATOMIC("Adding all current planes for [CRTC:%d:%s] to %p\n",
1229 crtc
->base
.id
, crtc
->name
, state
);
1231 drm_for_each_plane_mask(plane
, state
->dev
, old_crtc_state
->plane_mask
) {
1232 struct drm_plane_state
*plane_state
=
1233 drm_atomic_get_plane_state(state
, plane
);
1235 if (IS_ERR(plane_state
))
1236 return PTR_ERR(plane_state
);
1240 EXPORT_SYMBOL(drm_atomic_add_affected_planes
);
1243 * drm_atomic_check_only - check whether a given config would work
1244 * @state: atomic configuration to check
1246 * Note that this function can return -EDEADLK if the driver needed to acquire
1247 * more locks but encountered a deadlock. The caller must then do the usual w/w
1248 * backoff dance and restart. All other errors are fatal.
1251 * 0 on success, negative error code on failure.
1253 int drm_atomic_check_only(struct drm_atomic_state
*state
)
1255 struct drm_device
*dev
= state
->dev
;
1256 struct drm_mode_config
*config
= &dev
->mode_config
;
1257 struct drm_plane
*plane
;
1258 struct drm_plane_state
*old_plane_state
;
1259 struct drm_plane_state
*new_plane_state
;
1260 struct drm_crtc
*crtc
;
1261 struct drm_crtc_state
*old_crtc_state
;
1262 struct drm_crtc_state
*new_crtc_state
;
1263 struct drm_connector
*conn
;
1264 struct drm_connector_state
*conn_state
;
1267 DRM_DEBUG_ATOMIC("checking %p\n", state
);
1269 for_each_oldnew_plane_in_state(state
, plane
, old_plane_state
, new_plane_state
, i
) {
1270 ret
= drm_atomic_plane_check(old_plane_state
, new_plane_state
);
1272 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic core check failed\n",
1273 plane
->base
.id
, plane
->name
);
1278 for_each_oldnew_crtc_in_state(state
, crtc
, old_crtc_state
, new_crtc_state
, i
) {
1279 ret
= drm_atomic_crtc_check(old_crtc_state
, new_crtc_state
);
1281 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic core check failed\n",
1282 crtc
->base
.id
, crtc
->name
);
1287 for_each_new_connector_in_state(state
, conn
, conn_state
, i
) {
1288 ret
= drm_atomic_connector_check(conn
, conn_state
);
1290 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] atomic core check failed\n",
1291 conn
->base
.id
, conn
->name
);
1296 if (config
->funcs
->atomic_check
) {
1297 ret
= config
->funcs
->atomic_check(state
->dev
, state
);
1300 DRM_DEBUG_ATOMIC("atomic driver check for %p failed: %d\n",
1306 if (!state
->allow_modeset
) {
1307 for_each_new_crtc_in_state(state
, crtc
, new_crtc_state
, i
) {
1308 if (drm_atomic_crtc_needs_modeset(new_crtc_state
)) {
1309 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requires full modeset\n",
1310 crtc
->base
.id
, crtc
->name
);
1318 EXPORT_SYMBOL(drm_atomic_check_only
);
1321 * drm_atomic_commit - commit configuration atomically
1322 * @state: atomic configuration to check
1324 * Note that this function can return -EDEADLK if the driver needed to acquire
1325 * more locks but encountered a deadlock. The caller must then do the usual w/w
1326 * backoff dance and restart. All other errors are fatal.
1328 * This function will take its own reference on @state.
1329 * Callers should always release their reference with drm_atomic_state_put().
1332 * 0 on success, negative error code on failure.
1334 int drm_atomic_commit(struct drm_atomic_state
*state
)
1336 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1339 ret
= drm_atomic_check_only(state
);
1343 DRM_DEBUG_ATOMIC("committing %p\n", state
);
1345 return config
->funcs
->atomic_commit(state
->dev
, state
, false);
1347 EXPORT_SYMBOL(drm_atomic_commit
);
1350 * drm_atomic_nonblocking_commit - atomic nonblocking commit
1351 * @state: atomic configuration to check
1353 * Note that this function can return -EDEADLK if the driver needed to acquire
1354 * more locks but encountered a deadlock. The caller must then do the usual w/w
1355 * backoff dance and restart. All other errors are fatal.
1357 * This function will take its own reference on @state.
1358 * Callers should always release their reference with drm_atomic_state_put().
1361 * 0 on success, negative error code on failure.
1363 int drm_atomic_nonblocking_commit(struct drm_atomic_state
*state
)
1365 struct drm_mode_config
*config
= &state
->dev
->mode_config
;
1368 ret
= drm_atomic_check_only(state
);
1372 DRM_DEBUG_ATOMIC("committing %p nonblocking\n", state
);
1374 return config
->funcs
->atomic_commit(state
->dev
, state
, true);
1376 EXPORT_SYMBOL(drm_atomic_nonblocking_commit
);
1378 /* just used from drm-client and atomic-helper: */
1379 int __drm_atomic_helper_disable_plane(struct drm_plane
*plane
,
1380 struct drm_plane_state
*plane_state
)
1384 ret
= drm_atomic_set_crtc_for_plane(plane_state
, NULL
);
1388 drm_atomic_set_fb_for_plane(plane_state
, NULL
);
1389 plane_state
->crtc_x
= 0;
1390 plane_state
->crtc_y
= 0;
1391 plane_state
->crtc_w
= 0;
1392 plane_state
->crtc_h
= 0;
1393 plane_state
->src_x
= 0;
1394 plane_state
->src_y
= 0;
1395 plane_state
->src_w
= 0;
1396 plane_state
->src_h
= 0;
1400 EXPORT_SYMBOL(__drm_atomic_helper_disable_plane
);
1402 static int update_output_state(struct drm_atomic_state
*state
,
1403 struct drm_mode_set
*set
)
1405 struct drm_device
*dev
= set
->crtc
->dev
;
1406 struct drm_crtc
*crtc
;
1407 struct drm_crtc_state
*new_crtc_state
;
1408 struct drm_connector
*connector
;
1409 struct drm_connector_state
*new_conn_state
;
1412 ret
= drm_modeset_lock(&dev
->mode_config
.connection_mutex
,
1413 state
->acquire_ctx
);
1417 /* First disable all connectors on the target crtc. */
1418 ret
= drm_atomic_add_affected_connectors(state
, set
->crtc
);
1422 for_each_new_connector_in_state(state
, connector
, new_conn_state
, i
) {
1423 if (new_conn_state
->crtc
== set
->crtc
) {
1424 ret
= drm_atomic_set_crtc_for_connector(new_conn_state
,
1429 /* Make sure legacy setCrtc always re-trains */
1430 new_conn_state
->link_status
= DRM_LINK_STATUS_GOOD
;
1434 /* Then set all connectors from set->connectors on the target crtc */
1435 for (i
= 0; i
< set
->num_connectors
; i
++) {
1436 new_conn_state
= drm_atomic_get_connector_state(state
,
1437 set
->connectors
[i
]);
1438 if (IS_ERR(new_conn_state
))
1439 return PTR_ERR(new_conn_state
);
1441 ret
= drm_atomic_set_crtc_for_connector(new_conn_state
,
1447 for_each_new_crtc_in_state(state
, crtc
, new_crtc_state
, i
) {
1449 * Don't update ->enable for the CRTC in the set_config request,
1450 * since a mismatch would indicate a bug in the upper layers.
1451 * The actual modeset code later on will catch any
1452 * inconsistencies here.
1454 if (crtc
== set
->crtc
)
1457 if (!new_crtc_state
->connector_mask
) {
1458 ret
= drm_atomic_set_mode_prop_for_crtc(new_crtc_state
,
1463 new_crtc_state
->active
= false;
1470 /* just used from drm-client and atomic-helper: */
1471 int __drm_atomic_helper_set_config(struct drm_mode_set
*set
,
1472 struct drm_atomic_state
*state
)
1474 struct drm_crtc_state
*crtc_state
;
1475 struct drm_plane_state
*primary_state
;
1476 struct drm_crtc
*crtc
= set
->crtc
;
1477 int hdisplay
, vdisplay
;
1480 crtc_state
= drm_atomic_get_crtc_state(state
, crtc
);
1481 if (IS_ERR(crtc_state
))
1482 return PTR_ERR(crtc_state
);
1484 primary_state
= drm_atomic_get_plane_state(state
, crtc
->primary
);
1485 if (IS_ERR(primary_state
))
1486 return PTR_ERR(primary_state
);
1490 WARN_ON(set
->num_connectors
);
1492 ret
= drm_atomic_set_mode_for_crtc(crtc_state
, NULL
);
1496 crtc_state
->active
= false;
1498 ret
= drm_atomic_set_crtc_for_plane(primary_state
, NULL
);
1502 drm_atomic_set_fb_for_plane(primary_state
, NULL
);
1508 WARN_ON(!set
->num_connectors
);
1510 ret
= drm_atomic_set_mode_for_crtc(crtc_state
, set
->mode
);
1514 crtc_state
->active
= true;
1516 ret
= drm_atomic_set_crtc_for_plane(primary_state
, crtc
);
1520 drm_mode_get_hv_timing(set
->mode
, &hdisplay
, &vdisplay
);
1522 drm_atomic_set_fb_for_plane(primary_state
, set
->fb
);
1523 primary_state
->crtc_x
= 0;
1524 primary_state
->crtc_y
= 0;
1525 primary_state
->crtc_w
= hdisplay
;
1526 primary_state
->crtc_h
= vdisplay
;
1527 primary_state
->src_x
= set
->x
<< 16;
1528 primary_state
->src_y
= set
->y
<< 16;
1529 if (drm_rotation_90_or_270(primary_state
->rotation
)) {
1530 primary_state
->src_w
= vdisplay
<< 16;
1531 primary_state
->src_h
= hdisplay
<< 16;
1533 primary_state
->src_w
= hdisplay
<< 16;
1534 primary_state
->src_h
= vdisplay
<< 16;
1538 ret
= update_output_state(state
, set
);
1544 EXPORT_SYMBOL(__drm_atomic_helper_set_config
);
1546 void drm_atomic_print_state(const struct drm_atomic_state
*state
)
1548 struct drm_printer p
= drm_info_printer(state
->dev
->dev
);
1549 struct drm_plane
*plane
;
1550 struct drm_plane_state
*plane_state
;
1551 struct drm_crtc
*crtc
;
1552 struct drm_crtc_state
*crtc_state
;
1553 struct drm_connector
*connector
;
1554 struct drm_connector_state
*connector_state
;
1557 DRM_DEBUG_ATOMIC("checking %p\n", state
);
1559 for_each_new_plane_in_state(state
, plane
, plane_state
, i
)
1560 drm_atomic_plane_print_state(&p
, plane_state
);
1562 for_each_new_crtc_in_state(state
, crtc
, crtc_state
, i
)
1563 drm_atomic_crtc_print_state(&p
, crtc_state
);
1565 for_each_new_connector_in_state(state
, connector
, connector_state
, i
)
1566 drm_atomic_connector_print_state(&p
, connector_state
);
1569 static void __drm_state_dump(struct drm_device
*dev
, struct drm_printer
*p
,
1572 struct drm_mode_config
*config
= &dev
->mode_config
;
1573 struct drm_plane
*plane
;
1574 struct drm_crtc
*crtc
;
1575 struct drm_connector
*connector
;
1576 struct drm_connector_list_iter conn_iter
;
1578 if (!drm_drv_uses_atomic_modeset(dev
))
1581 list_for_each_entry(plane
, &config
->plane_list
, head
) {
1583 drm_modeset_lock(&plane
->mutex
, NULL
);
1584 drm_atomic_plane_print_state(p
, plane
->state
);
1586 drm_modeset_unlock(&plane
->mutex
);
1589 list_for_each_entry(crtc
, &config
->crtc_list
, head
) {
1591 drm_modeset_lock(&crtc
->mutex
, NULL
);
1592 drm_atomic_crtc_print_state(p
, crtc
->state
);
1594 drm_modeset_unlock(&crtc
->mutex
);
1597 drm_connector_list_iter_begin(dev
, &conn_iter
);
1599 drm_modeset_lock(&dev
->mode_config
.connection_mutex
, NULL
);
1600 drm_for_each_connector_iter(connector
, &conn_iter
)
1601 drm_atomic_connector_print_state(p
, connector
->state
);
1603 drm_modeset_unlock(&dev
->mode_config
.connection_mutex
);
1604 drm_connector_list_iter_end(&conn_iter
);
1608 * drm_state_dump - dump entire device atomic state
1609 * @dev: the drm device
1610 * @p: where to print the state to
1612 * Just for debugging. Drivers might want an option to dump state
1613 * to dmesg in case of error irq's. (Hint, you probably want to
1616 * The caller must drm_modeset_lock_all(), or if this is called
1617 * from error irq handler, it should not be enabled by default.
1618 * (Ie. if you are debugging errors you might not care that this
1619 * is racey. But calling this without all modeset locks held is
1620 * not inherently safe.)
1622 void drm_state_dump(struct drm_device
*dev
, struct drm_printer
*p
)
1624 __drm_state_dump(dev
, p
, false);
1626 EXPORT_SYMBOL(drm_state_dump
);
1628 #ifdef CONFIG_DEBUG_FS
1629 static int drm_state_info(struct seq_file
*m
, void *data
)
1631 struct drm_info_node
*node
= (struct drm_info_node
*) m
->private;
1632 struct drm_device
*dev
= node
->minor
->dev
;
1633 struct drm_printer p
= drm_seq_file_printer(m
);
1635 __drm_state_dump(dev
, &p
, true);
1640 /* any use in debugfs files to dump individual planes/crtc/etc? */
1641 static const struct drm_info_list drm_atomic_debugfs_list
[] = {
1642 {"state", drm_state_info
, 0},
1645 void drm_atomic_debugfs_init(struct drm_minor
*minor
)
1647 drm_debugfs_create_files(drm_atomic_debugfs_list
,
1648 ARRAY_SIZE(drm_atomic_debugfs_list
),
1649 minor
->debugfs_root
, minor
);