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>
31 #include <drm/drm_crtc.h>
34 * struct drm_crtc_commit - track modeset commits on a CRTC
36 * This structure is used to track pending modeset changes and atomic commit on
37 * a per-CRTC basis. Since updating the list should never block this structure
38 * is reference counted to allow waiters to safely wait on an event to complete,
39 * without holding any locks.
41 * It has 3 different events in total to allow a fine-grained synchronization
42 * between outstanding updates::
44 * atomic commit thread hardware
46 * write new state into hardware ----> ...
48 * switch to new state on next
51 * wait for buffers to show up ...
53 * ... send completion irq
54 * irq handler signals flip_done
59 * wait for flip_done <----
60 * clean up atomic state
62 * The important bit to know is that cleanup_done is the terminal event, but the
63 * ordering between flip_done and hw_done is entirely up to the specific driver
64 * and modeset state change.
66 * For an implementation of how to use this look at
67 * drm_atomic_helper_setup_commit() from the atomic helper library.
69 struct drm_crtc_commit {
73 * DRM CRTC for this commit.
75 struct drm_crtc *crtc;
80 * Reference count for this structure. Needed to allow blocking on
81 * completions without the risk of the completion disappearing
89 * Will be signaled when the hardware has flipped to the new set of
90 * buffers. Signals at the same time as when the drm event for this
91 * commit is sent to userspace, or when an out-fence is singalled. Note
92 * that for most hardware, in most cases this happens after @hw_done is
95 struct completion flip_done;
100 * Will be signalled when all hw register changes for this commit have
101 * been written out. Especially when disabling a pipe this can be much
102 * later than than @flip_done, since that can signal already when the
103 * screen goes black, whereas to fully shut down a pipe more register
106 * Note that this does not need to include separately reference-counted
107 * resources like backing storage buffer pinning, or runtime pm
110 struct completion hw_done;
115 * Will be signalled after old buffers have been cleaned up by calling
116 * drm_atomic_helper_cleanup_planes(). Since this can only happen after
117 * a vblank wait completed it might be a bit later. This completion is
118 * useful to throttle updates and avoid hardware updates getting ahead
119 * of the buffer cleanup too much.
121 struct completion cleanup_done;
126 * Entry on the per-CRTC &drm_crtc.commit_list. Protected by
127 * $drm_crtc.commit_lock.
129 struct list_head commit_entry;
134 * &drm_pending_vblank_event pointer to clean up private events.
136 struct drm_pending_vblank_event *event;
139 struct __drm_planes_state {
140 struct drm_plane *ptr;
141 struct drm_plane_state *state, *old_state, *new_state;
144 struct __drm_crtcs_state {
145 struct drm_crtc *ptr;
146 struct drm_crtc_state *state, *old_state, *new_state;
147 struct drm_crtc_commit *commit;
148 s32 __user *out_fence_ptr;
149 unsigned last_vblank_count;
152 struct __drm_connnectors_state {
153 struct drm_connector *ptr;
154 struct drm_connector_state *state, *old_state, *new_state;
158 * struct drm_atomic_state - the global state object for atomic updates
159 * @ref: count of all references to this state (will not be freed until zero)
160 * @dev: parent DRM device
161 * @allow_modeset: allow full modeset
162 * @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics
163 * @planes: pointer to array of structures with per-plane data
164 * @crtcs: pointer to array of CRTC pointers
165 * @num_connector: size of the @connectors and @connector_states arrays
166 * @connectors: pointer to array of structures with per-connector data
167 * @acquire_ctx: acquire context for this atomic modeset state update
169 struct drm_atomic_state {
172 struct drm_device *dev;
173 bool allow_modeset : 1;
174 bool legacy_cursor_update : 1;
175 struct __drm_planes_state *planes;
176 struct __drm_crtcs_state *crtcs;
178 struct __drm_connnectors_state *connectors;
180 struct drm_modeset_acquire_ctx *acquire_ctx;
185 * Work item which can be used by the driver or helpers to execute the
186 * commit without blocking.
188 struct work_struct commit_work;
191 void __drm_crtc_commit_free(struct kref *kref);
194 * drm_crtc_commit_get - acquire a reference to the CRTC commit
195 * @commit: CRTC commit
197 * Increases the reference of @commit.
199 static inline void drm_crtc_commit_get(struct drm_crtc_commit *commit)
201 kref_get(&commit->ref);
205 * drm_crtc_commit_put - release a reference to the CRTC commmit
206 * @commit: CRTC commit
208 * This releases a reference to @commit which is freed after removing the
209 * final reference. No locking required and callable from any context.
211 static inline void drm_crtc_commit_put(struct drm_crtc_commit *commit)
213 kref_put(&commit->ref, __drm_crtc_commit_free);
216 struct drm_atomic_state * __must_check
217 drm_atomic_state_alloc(struct drm_device *dev);
218 void drm_atomic_state_clear(struct drm_atomic_state *state);
221 * drm_atomic_state_get - acquire a reference to the atomic state
222 * @state: The atomic state
224 * Returns a new reference to the @state
226 static inline struct drm_atomic_state *
227 drm_atomic_state_get(struct drm_atomic_state *state)
229 kref_get(&state->ref);
233 void __drm_atomic_state_free(struct kref *ref);
236 * drm_atomic_state_put - release a reference to the atomic state
237 * @state: The atomic state
239 * This releases a reference to @state which is freed after removing the
240 * final reference. No locking required and callable from any context.
242 static inline void drm_atomic_state_put(struct drm_atomic_state *state)
244 kref_put(&state->ref, __drm_atomic_state_free);
248 drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state);
249 void drm_atomic_state_default_clear(struct drm_atomic_state *state);
250 void drm_atomic_state_default_release(struct drm_atomic_state *state);
252 struct drm_crtc_state * __must_check
253 drm_atomic_get_crtc_state(struct drm_atomic_state *state,
254 struct drm_crtc *crtc);
255 int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
256 struct drm_crtc_state *state, struct drm_property *property,
258 struct drm_plane_state * __must_check
259 drm_atomic_get_plane_state(struct drm_atomic_state *state,
260 struct drm_plane *plane);
261 int drm_atomic_plane_set_property(struct drm_plane *plane,
262 struct drm_plane_state *state, struct drm_property *property,
264 struct drm_connector_state * __must_check
265 drm_atomic_get_connector_state(struct drm_atomic_state *state,
266 struct drm_connector *connector);
267 int drm_atomic_connector_set_property(struct drm_connector *connector,
268 struct drm_connector_state *state, struct drm_property *property,
272 * drm_atomic_get_existing_crtc_state - get crtc state, if it exists
273 * @state: global atomic state object
274 * @crtc: crtc to grab
276 * This function returns the crtc state for the given crtc, or NULL
277 * if the crtc is not part of the global atomic state.
279 * This function is deprecated, @drm_atomic_get_old_crtc_state or
280 * @drm_atomic_get_new_crtc_state should be used instead.
282 static inline struct drm_crtc_state *
283 drm_atomic_get_existing_crtc_state(struct drm_atomic_state *state,
284 struct drm_crtc *crtc)
286 return state->crtcs[drm_crtc_index(crtc)].state;
290 * drm_atomic_get_old_crtc_state - get old crtc state, if it exists
291 * @state: global atomic state object
292 * @crtc: crtc to grab
294 * This function returns the old crtc state for the given crtc, or
295 * NULL if the crtc is not part of the global atomic state.
297 static inline struct drm_crtc_state *
298 drm_atomic_get_old_crtc_state(struct drm_atomic_state *state,
299 struct drm_crtc *crtc)
301 return state->crtcs[drm_crtc_index(crtc)].old_state;
304 * drm_atomic_get_new_crtc_state - get new crtc state, if it exists
305 * @state: global atomic state object
306 * @crtc: crtc to grab
308 * This function returns the new crtc state for the given crtc, or
309 * NULL if the crtc is not part of the global atomic state.
311 static inline struct drm_crtc_state *
312 drm_atomic_get_new_crtc_state(struct drm_atomic_state *state,
313 struct drm_crtc *crtc)
315 return state->crtcs[drm_crtc_index(crtc)].new_state;
319 * drm_atomic_get_existing_plane_state - get plane state, if it exists
320 * @state: global atomic state object
321 * @plane: plane to grab
323 * This function returns the plane state for the given plane, or NULL
324 * if the plane is not part of the global atomic state.
326 * This function is deprecated, @drm_atomic_get_old_plane_state or
327 * @drm_atomic_get_new_plane_state should be used instead.
329 static inline struct drm_plane_state *
330 drm_atomic_get_existing_plane_state(struct drm_atomic_state *state,
331 struct drm_plane *plane)
333 return state->planes[drm_plane_index(plane)].state;
337 * drm_atomic_get_old_plane_state - get plane state, if it exists
338 * @state: global atomic state object
339 * @plane: plane to grab
341 * This function returns the old plane state for the given plane, or
342 * NULL if the plane is not part of the global atomic state.
344 static inline struct drm_plane_state *
345 drm_atomic_get_old_plane_state(struct drm_atomic_state *state,
346 struct drm_plane *plane)
348 return state->planes[drm_plane_index(plane)].old_state;
352 * drm_atomic_get_new_plane_state - get plane state, if it exists
353 * @state: global atomic state object
354 * @plane: plane to grab
356 * This function returns the new plane state for the given plane, or
357 * NULL if the plane is not part of the global atomic state.
359 static inline struct drm_plane_state *
360 drm_atomic_get_new_plane_state(struct drm_atomic_state *state,
361 struct drm_plane *plane)
363 return state->planes[drm_plane_index(plane)].new_state;
367 * drm_atomic_get_existing_connector_state - get connector state, if it exists
368 * @state: global atomic state object
369 * @connector: connector to grab
371 * This function returns the connector state for the given connector,
372 * or NULL if the connector is not part of the global atomic state.
374 * This function is deprecated, @drm_atomic_get_old_connector_state or
375 * @drm_atomic_get_new_connector_state should be used instead.
377 static inline struct drm_connector_state *
378 drm_atomic_get_existing_connector_state(struct drm_atomic_state *state,
379 struct drm_connector *connector)
381 int index = drm_connector_index(connector);
383 if (index >= state->num_connector)
386 return state->connectors[index].state;
390 * drm_atomic_get_old_connector_state - get connector state, if it exists
391 * @state: global atomic state object
392 * @connector: connector to grab
394 * This function returns the old connector state for the given connector,
395 * or NULL if the connector is not part of the global atomic state.
397 static inline struct drm_connector_state *
398 drm_atomic_get_old_connector_state(struct drm_atomic_state *state,
399 struct drm_connector *connector)
401 int index = drm_connector_index(connector);
403 if (index >= state->num_connector)
406 return state->connectors[index].old_state;
410 * drm_atomic_get_new_connector_state - get connector state, if it exists
411 * @state: global atomic state object
412 * @connector: connector to grab
414 * This function returns the new connector state for the given connector,
415 * or NULL if the connector is not part of the global atomic state.
417 static inline struct drm_connector_state *
418 drm_atomic_get_new_connector_state(struct drm_atomic_state *state,
419 struct drm_connector *connector)
421 int index = drm_connector_index(connector);
423 if (index >= state->num_connector)
426 return state->connectors[index].new_state;
430 * __drm_atomic_get_current_plane_state - get current plane state
431 * @state: global atomic state object
432 * @plane: plane to grab
434 * This function returns the plane state for the given plane, either from
435 * @state, or if the plane isn't part of the atomic state update, from @plane.
436 * This is useful in atomic check callbacks, when drivers need to peek at, but
437 * not change, state of other planes, since it avoids threading an error code
438 * back up the call chain.
442 * Note that this function is in general unsafe since it doesn't check for the
443 * required locking for access state structures. Drivers must ensure that it is
444 * safe to access the returned state structure through other means. One common
445 * example is when planes are fixed to a single CRTC, and the driver knows that
446 * the CRTC lock is held already. In that case holding the CRTC lock gives a
447 * read-lock on all planes connected to that CRTC. But if planes can be
448 * reassigned things get more tricky. In that case it's better to use
449 * drm_atomic_get_plane_state and wire up full error handling.
453 * Read-only pointer to the current plane state.
455 static inline const struct drm_plane_state *
456 __drm_atomic_get_current_plane_state(struct drm_atomic_state *state,
457 struct drm_plane *plane)
459 if (state->planes[drm_plane_index(plane)].state)
460 return state->planes[drm_plane_index(plane)].state;
466 drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,
467 struct drm_display_mode *mode);
469 drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,
470 struct drm_property_blob *blob);
472 drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
473 struct drm_crtc *crtc);
474 void drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
475 struct drm_framebuffer *fb);
476 void drm_atomic_set_fence_for_plane(struct drm_plane_state *plane_state,
477 struct dma_fence *fence);
479 drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
480 struct drm_crtc *crtc);
482 drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
483 struct drm_crtc *crtc);
485 drm_atomic_add_affected_planes(struct drm_atomic_state *state,
486 struct drm_crtc *crtc);
488 void drm_atomic_legacy_backoff(struct drm_atomic_state *state);
491 drm_atomic_clean_old_fb(struct drm_device *dev, unsigned plane_mask, int ret);
493 int __must_check drm_atomic_check_only(struct drm_atomic_state *state);
494 int __must_check drm_atomic_commit(struct drm_atomic_state *state);
495 int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_state *state);
497 void drm_state_dump(struct drm_device *dev, struct drm_printer *p);
500 * for_each_connector_in_state - iterate over all connectors in an atomic update
501 * @__state: &struct drm_atomic_state pointer
502 * @connector: &struct drm_connector iteration cursor
503 * @connector_state: &struct drm_connector_state iteration cursor
504 * @__i: int iteration cursor, for macro-internal use
506 * This iterates over all connectors in an atomic update. Note that before the
507 * software state is committed (by calling drm_atomic_helper_swap_state(), this
508 * points to the new state, while afterwards it points to the old state. Due to
509 * this tricky confusion this macro is deprecated.
513 * Replace all usage of this with one of the explicit iterators below and then
516 #define for_each_connector_in_state(__state, connector, connector_state, __i) \
518 (__i) < (__state)->num_connector && \
519 ((connector) = (__state)->connectors[__i].ptr, \
520 (connector_state) = (__state)->connectors[__i].state, 1); \
522 for_each_if (connector)
525 * for_each_oldnew_connector_in_state - iterate over all connectors in an atomic update
526 * @__state: &struct drm_atomic_state pointer
527 * @connector: &struct drm_connector iteration cursor
528 * @old_connector_state: &struct drm_connector_state iteration cursor for the
530 * @new_connector_state: &struct drm_connector_state iteration cursor for the
532 * @__i: int iteration cursor, for macro-internal use
534 * This iterates over all connectors in an atomic update, tracking both old and
535 * new state. This is useful in places where the state delta needs to be
536 * considered, for example in atomic check functions.
538 #define for_each_oldnew_connector_in_state(__state, connector, old_connector_state, new_connector_state, __i) \
540 (__i) < (__state)->num_connector && \
541 ((connector) = (__state)->connectors[__i].ptr, \
542 (old_connector_state) = (__state)->connectors[__i].old_state, \
543 (new_connector_state) = (__state)->connectors[__i].new_state, 1); \
545 for_each_if (connector)
548 * for_each_old_connector_in_state - iterate over all connectors in an atomic update
549 * @__state: &struct drm_atomic_state pointer
550 * @connector: &struct drm_connector iteration cursor
551 * @old_connector_state: &struct drm_connector_state iteration cursor for the
553 * @__i: int iteration cursor, for macro-internal use
555 * This iterates over all connectors in an atomic update, tracking only the old
556 * state. This is useful in disable functions, where we need the old state the
557 * hardware is still in.
559 #define for_each_old_connector_in_state(__state, connector, old_connector_state, __i) \
561 (__i) < (__state)->num_connector && \
562 ((connector) = (__state)->connectors[__i].ptr, \
563 (old_connector_state) = (__state)->connectors[__i].old_state, 1); \
565 for_each_if (connector)
568 * for_each_new_connector_in_state - iterate over all connectors in an atomic update
569 * @__state: &struct drm_atomic_state pointer
570 * @connector: &struct drm_connector iteration cursor
571 * @new_connector_state: &struct drm_connector_state iteration cursor for the
573 * @__i: int iteration cursor, for macro-internal use
575 * This iterates over all connectors in an atomic update, tracking only the new
576 * state. This is useful in enable functions, where we need the new state the
577 * hardware should be in when the atomic commit operation has completed.
579 #define for_each_new_connector_in_state(__state, connector, new_connector_state, __i) \
581 (__i) < (__state)->num_connector && \
582 ((connector) = (__state)->connectors[__i].ptr, \
583 (new_connector_state) = (__state)->connectors[__i].new_state, 1); \
585 for_each_if (connector)
588 * for_each_crtc_in_state - iterate over all connectors in an atomic update
589 * @__state: &struct drm_atomic_state pointer
590 * @crtc: &struct drm_crtc iteration cursor
591 * @crtc_state: &struct drm_crtc_state iteration cursor
592 * @__i: int iteration cursor, for macro-internal use
594 * This iterates over all CRTCs in an atomic update. Note that before the
595 * software state is committed (by calling drm_atomic_helper_swap_state(), this
596 * points to the new state, while afterwards it points to the old state. Due to
597 * this tricky confusion this macro is deprecated.
601 * Replace all usage of this with one of the explicit iterators below and then
604 #define for_each_crtc_in_state(__state, crtc, crtc_state, __i) \
606 (__i) < (__state)->dev->mode_config.num_crtc && \
607 ((crtc) = (__state)->crtcs[__i].ptr, \
608 (crtc_state) = (__state)->crtcs[__i].state, 1); \
610 for_each_if (crtc_state)
613 * for_each_oldnew_crtc_in_state - iterate over all CRTCs in an atomic update
614 * @__state: &struct drm_atomic_state pointer
615 * @crtc: &struct drm_crtc iteration cursor
616 * @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state
617 * @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state
618 * @__i: int iteration cursor, for macro-internal use
620 * This iterates over all CRTCs in an atomic update, tracking both old and
621 * new state. This is useful in places where the state delta needs to be
622 * considered, for example in atomic check functions.
624 #define for_each_oldnew_crtc_in_state(__state, crtc, old_crtc_state, new_crtc_state, __i) \
626 (__i) < (__state)->dev->mode_config.num_crtc && \
627 ((crtc) = (__state)->crtcs[__i].ptr, \
628 (old_crtc_state) = (__state)->crtcs[__i].old_state, \
629 (new_crtc_state) = (__state)->crtcs[__i].new_state, 1); \
634 * for_each_old_crtc_in_state - iterate over all CRTCs in an atomic update
635 * @__state: &struct drm_atomic_state pointer
636 * @crtc: &struct drm_crtc iteration cursor
637 * @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state
638 * @__i: int iteration cursor, for macro-internal use
640 * This iterates over all CRTCs in an atomic update, tracking only the old
641 * state. This is useful in disable functions, where we need the old state the
642 * hardware is still in.
644 #define for_each_old_crtc_in_state(__state, crtc, old_crtc_state, __i) \
646 (__i) < (__state)->dev->mode_config.num_crtc && \
647 ((crtc) = (__state)->crtcs[__i].ptr, \
648 (old_crtc_state) = (__state)->crtcs[__i].old_state, 1); \
653 * for_each_new_crtc_in_state - iterate over all CRTCs in an atomic update
654 * @__state: &struct drm_atomic_state pointer
655 * @crtc: &struct drm_crtc iteration cursor
656 * @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state
657 * @__i: int iteration cursor, for macro-internal use
659 * This iterates over all CRTCs in an atomic update, tracking only the new
660 * state. This is useful in enable functions, where we need the new state the
661 * hardware should be in when the atomic commit operation has completed.
663 #define for_each_new_crtc_in_state(__state, crtc, new_crtc_state, __i) \
665 (__i) < (__state)->dev->mode_config.num_crtc && \
666 ((crtc) = (__state)->crtcs[__i].ptr, \
667 (new_crtc_state) = (__state)->crtcs[__i].new_state, 1); \
672 * for_each_plane_in_state - iterate over all planes in an atomic update
673 * @__state: &struct drm_atomic_state pointer
674 * @plane: &struct drm_plane iteration cursor
675 * @plane_state: &struct drm_plane_state iteration cursor
676 * @__i: int iteration cursor, for macro-internal use
678 * This iterates over all planes in an atomic update. Note that before the
679 * software state is committed (by calling drm_atomic_helper_swap_state(), this
680 * points to the new state, while afterwards it points to the old state. Due to
681 * this tricky confusion this macro is deprecated.
685 * Replace all usage of this with one of the explicit iterators below and then
688 #define for_each_plane_in_state(__state, plane, plane_state, __i) \
690 (__i) < (__state)->dev->mode_config.num_total_plane && \
691 ((plane) = (__state)->planes[__i].ptr, \
692 (plane_state) = (__state)->planes[__i].state, 1); \
694 for_each_if (plane_state)
697 * for_each_oldnew_plane_in_state - iterate over all planes in an atomic update
698 * @__state: &struct drm_atomic_state pointer
699 * @plane: &struct drm_plane iteration cursor
700 * @old_plane_state: &struct drm_plane_state iteration cursor for the old state
701 * @new_plane_state: &struct drm_plane_state iteration cursor for the new state
702 * @__i: int iteration cursor, for macro-internal use
704 * This iterates over all planes in an atomic update, tracking both old and
705 * new state. This is useful in places where the state delta needs to be
706 * considered, for example in atomic check functions.
708 #define for_each_oldnew_plane_in_state(__state, plane, old_plane_state, new_plane_state, __i) \
710 (__i) < (__state)->dev->mode_config.num_total_plane && \
711 ((plane) = (__state)->planes[__i].ptr, \
712 (old_plane_state) = (__state)->planes[__i].old_state, \
713 (new_plane_state) = (__state)->planes[__i].new_state, 1); \
718 * for_each_old_plane_in_state - iterate over all planes in an atomic update
719 * @__state: &struct drm_atomic_state pointer
720 * @plane: &struct drm_plane iteration cursor
721 * @old_plane_state: &struct drm_plane_state iteration cursor for the old state
722 * @__i: int iteration cursor, for macro-internal use
724 * This iterates over all planes in an atomic update, tracking only the old
725 * state. This is useful in disable functions, where we need the old state the
726 * hardware is still in.
728 #define for_each_old_plane_in_state(__state, plane, old_plane_state, __i) \
730 (__i) < (__state)->dev->mode_config.num_total_plane && \
731 ((plane) = (__state)->planes[__i].ptr, \
732 (old_plane_state) = (__state)->planes[__i].old_state, 1); \
737 * for_each_new_plane_in_state - iterate over all planes in an atomic update
738 * @__state: &struct drm_atomic_state pointer
739 * @plane: &struct drm_plane iteration cursor
740 * @new_plane_state: &struct drm_plane_state iteration cursor for the new state
741 * @__i: int iteration cursor, for macro-internal use
743 * This iterates over all planes in an atomic update, tracking only the new
744 * state. This is useful in enable functions, where we need the new state the
745 * hardware should be in when the atomic commit operation has completed.
747 #define for_each_new_plane_in_state(__state, plane, new_plane_state, __i) \
749 (__i) < (__state)->dev->mode_config.num_total_plane && \
750 ((plane) = (__state)->planes[__i].ptr, \
751 (new_plane_state) = (__state)->planes[__i].new_state, 1); \
756 * drm_atomic_crtc_needs_modeset - compute combined modeset need
757 * @state: &drm_crtc_state for the CRTC
759 * To give drivers flexibility &struct drm_crtc_state has 3 booleans to track
760 * whether the state CRTC changed enough to need a full modeset cycle:
761 * planes_changed, mode_changed and active_changed. This helper simply
762 * combines these three to compute the overall need for a modeset for @state.
764 * The atomic helper code sets these booleans, but drivers can and should
765 * change them appropriately to accurately represent whether a modeset is
766 * really needed. In general, drivers should avoid full modesets whenever
769 * For example if the CRTC mode has changed, and the hardware is able to enact
770 * the requested mode change without going through a full modeset, the driver
771 * should clear mode_changed in its &drm_mode_config_funcs.atomic_check
775 drm_atomic_crtc_needs_modeset(const struct drm_crtc_state *state)
777 return state->mode_changed || state->active_changed ||
778 state->connectors_changed;
781 #endif /* DRM_ATOMIC_H_ */