blob: 788daf756f489c1076eae5c4470e7be309bf4285 [file] [log] [blame]
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001/*
2 * Copyright (C) 2014 Red Hat
3 * Copyright (C) 2014 Intel Corp.
4 *
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:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
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.
22 *
23 * Authors:
24 * Rob Clark <robdclark@gmail.com>
25 * Daniel Vetter <daniel.vetter@ffwll.ch>
26 */
27
28#ifndef DRM_ATOMIC_H_
29#define DRM_ATOMIC_H_
30
Thierry Reding37cc0142014-11-25 12:09:48 +010031#include <drm/drm_crtc.h>
32
Daniel Vetter43968d72016-09-21 10:59:24 +020033/**
34 * struct drm_crtc_commit - track modeset commits on a CRTC
35 *
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.
40 *
41 * It has 3 different events in total to allow a fine-grained synchronization
42 * between outstanding updates::
43 *
44 * atomic commit thread hardware
45 *
46 * write new state into hardware ----> ...
47 * signal hw_done
48 * switch to new state on next
49 * ... v/hblank
50 *
51 * wait for buffers to show up ...
52 *
53 * ... send completion irq
54 * irq handler signals flip_done
55 * cleanup old buffers
56 *
57 * signal cleanup_done
58 *
59 * wait for flip_done <----
60 * clean up atomic state
61 *
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.
65 *
66 * For an implementation of how to use this look at
67 * drm_atomic_helper_setup_commit() from the atomic helper library.
68 */
69struct drm_crtc_commit {
70 /**
71 * @crtc:
72 *
73 * DRM CRTC for this commit.
74 */
75 struct drm_crtc *crtc;
76
77 /**
78 * @ref:
79 *
80 * Reference count for this structure. Needed to allow blocking on
81 * completions without the risk of the completion disappearing
82 * meanwhile.
83 */
84 struct kref ref;
85
86 /**
87 * @flip_done:
88 *
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
93 * signalled.
94 */
95 struct completion flip_done;
96
97 /**
98 * @hw_done:
99 *
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
104 * I/O is required.
105 *
106 * Note that this does not need to include separately reference-counted
107 * resources like backing storage buffer pinning, or runtime pm
108 * management.
109 */
110 struct completion hw_done;
111
112 /**
113 * @cleanup_done:
114 *
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.
120 */
121 struct completion cleanup_done;
122
123 /**
124 * @commit_entry:
125 *
Daniel Vetterd5745282017-01-25 07:26:45 +0100126 * Entry on the per-CRTC &drm_crtc.commit_list. Protected by
127 * $drm_crtc.commit_lock.
Daniel Vetter43968d72016-09-21 10:59:24 +0200128 */
129 struct list_head commit_entry;
130
131 /**
132 * @event:
133 *
134 * &drm_pending_vblank_event pointer to clean up private events.
135 */
136 struct drm_pending_vblank_event *event;
137};
138
139struct __drm_planes_state {
140 struct drm_plane *ptr;
Maarten Lankhorst581e49f2017-01-16 10:37:38 +0100141 struct drm_plane_state *state, *old_state, *new_state;
Daniel Vetter43968d72016-09-21 10:59:24 +0200142};
143
144struct __drm_crtcs_state {
145 struct drm_crtc *ptr;
Maarten Lankhorst581e49f2017-01-16 10:37:38 +0100146 struct drm_crtc_state *state, *old_state, *new_state;
Daniel Vetter43968d72016-09-21 10:59:24 +0200147 struct drm_crtc_commit *commit;
Gustavo Padovan7e9081c2017-01-13 12:22:09 -0200148 s32 __user *out_fence_ptr;
Maarten Lankhorstbdc57142016-12-15 12:51:42 +0100149 unsigned last_vblank_count;
Daniel Vetter43968d72016-09-21 10:59:24 +0200150};
151
152struct __drm_connnectors_state {
153 struct drm_connector *ptr;
Maarten Lankhorst581e49f2017-01-16 10:37:38 +0100154 struct drm_connector_state *state, *old_state, *new_state;
Daniel Vetter43968d72016-09-21 10:59:24 +0200155};
156
157/**
158 * struct drm_atomic_state - the global state object for atomic updates
Chris Wilson08536952016-10-14 13:18:18 +0100159 * @ref: count of all references to this state (will not be freed until zero)
Daniel Vetter43968d72016-09-21 10:59:24 +0200160 * @dev: parent DRM device
161 * @allow_modeset: allow full modeset
162 * @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics
Daniel Vetter43968d72016-09-21 10:59:24 +0200163 * @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
168 */
169struct drm_atomic_state {
Chris Wilson08536952016-10-14 13:18:18 +0100170 struct kref ref;
171
Daniel Vetter43968d72016-09-21 10:59:24 +0200172 struct drm_device *dev;
173 bool allow_modeset : 1;
174 bool legacy_cursor_update : 1;
Daniel Vetter43968d72016-09-21 10:59:24 +0200175 struct __drm_planes_state *planes;
176 struct __drm_crtcs_state *crtcs;
177 int num_connector;
178 struct __drm_connnectors_state *connectors;
179
180 struct drm_modeset_acquire_ctx *acquire_ctx;
181
182 /**
183 * @commit_work:
184 *
185 * Work item which can be used by the driver or helpers to execute the
186 * commit without blocking.
187 */
188 struct work_struct commit_work;
189};
190
Daniel Vetterb3ba3f6f2016-12-21 14:03:35 +0100191void __drm_crtc_commit_free(struct kref *kref);
192
193/**
194 * drm_crtc_commit_get - acquire a reference to the CRTC commit
195 * @commit: CRTC commit
196 *
197 * Increases the reference of @commit.
198 */
Daniel Vetter3b24f7d2016-06-08 14:19:00 +0200199static inline void drm_crtc_commit_get(struct drm_crtc_commit *commit)
200{
201 kref_get(&commit->ref);
202}
203
Daniel Vetterb3ba3f6f2016-12-21 14:03:35 +0100204/**
205 * drm_crtc_commit_put - release a reference to the CRTC commmit
206 * @commit: CRTC commit
207 *
208 * This releases a reference to @commit which is freed after removing the
209 * final reference. No locking required and callable from any context.
210 */
211static inline void drm_crtc_commit_put(struct drm_crtc_commit *commit)
212{
213 kref_put(&commit->ref, __drm_crtc_commit_free);
214}
215
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200216struct drm_atomic_state * __must_check
217drm_atomic_state_alloc(struct drm_device *dev);
218void drm_atomic_state_clear(struct drm_atomic_state *state);
Chris Wilson08536952016-10-14 13:18:18 +0100219
220/**
221 * drm_atomic_state_get - acquire a reference to the atomic state
222 * @state: The atomic state
223 *
224 * Returns a new reference to the @state
225 */
226static inline struct drm_atomic_state *
227drm_atomic_state_get(struct drm_atomic_state *state)
228{
229 kref_get(&state->ref);
230 return state;
231}
232
233void __drm_atomic_state_free(struct kref *ref);
234
235/**
236 * drm_atomic_state_put - release a reference to the atomic state
237 * @state: The atomic state
238 *
239 * This releases a reference to @state which is freed after removing the
240 * final reference. No locking required and callable from any context.
241 */
242static inline void drm_atomic_state_put(struct drm_atomic_state *state)
243{
244 kref_put(&state->ref, __drm_atomic_state_free);
245}
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200246
Maarten Lankhorst036ef572015-05-18 10:06:40 +0200247int __must_check
248drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state);
249void drm_atomic_state_default_clear(struct drm_atomic_state *state);
250void drm_atomic_state_default_release(struct drm_atomic_state *state);
251
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200252struct drm_crtc_state * __must_check
253drm_atomic_get_crtc_state(struct drm_atomic_state *state,
254 struct drm_crtc *crtc);
Rob Clark40ecc692014-12-18 16:01:46 -0500255int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
256 struct drm_crtc_state *state, struct drm_property *property,
257 uint64_t val);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200258struct drm_plane_state * __must_check
259drm_atomic_get_plane_state(struct drm_atomic_state *state,
260 struct drm_plane *plane);
Rob Clark40ecc692014-12-18 16:01:46 -0500261int drm_atomic_plane_set_property(struct drm_plane *plane,
262 struct drm_plane_state *state, struct drm_property *property,
263 uint64_t val);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200264struct drm_connector_state * __must_check
265drm_atomic_get_connector_state(struct drm_atomic_state *state,
266 struct drm_connector *connector);
Rob Clark40ecc692014-12-18 16:01:46 -0500267int drm_atomic_connector_set_property(struct drm_connector *connector,
268 struct drm_connector_state *state, struct drm_property *property,
269 uint64_t val);
Rob Clark88a48e22014-12-18 16:01:50 -0500270
Maarten Lankhorst1b26a5e2015-05-13 10:37:25 +0200271/**
272 * drm_atomic_get_existing_crtc_state - get crtc state, if it exists
273 * @state: global atomic state object
274 * @crtc: crtc to grab
275 *
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.
Maarten Lankhorst21077772017-02-16 15:47:08 +0100278 *
279 * This function is deprecated, @drm_atomic_get_old_crtc_state or
280 * @drm_atomic_get_new_crtc_state should be used instead.
Maarten Lankhorst1b26a5e2015-05-13 10:37:25 +0200281 */
282static inline struct drm_crtc_state *
283drm_atomic_get_existing_crtc_state(struct drm_atomic_state *state,
284 struct drm_crtc *crtc)
285{
Daniel Vetter5d943aa62016-06-02 00:06:34 +0200286 return state->crtcs[drm_crtc_index(crtc)].state;
Maarten Lankhorst1b26a5e2015-05-13 10:37:25 +0200287}
288
289/**
Maarten Lankhorst21077772017-02-16 15:47:08 +0100290 * drm_atomic_get_old_crtc_state - get old crtc state, if it exists
291 * @state: global atomic state object
292 * @crtc: crtc to grab
293 *
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.
296 */
297static inline struct drm_crtc_state *
298drm_atomic_get_old_crtc_state(struct drm_atomic_state *state,
299 struct drm_crtc *crtc)
300{
301 return state->crtcs[drm_crtc_index(crtc)].old_state;
302}
303/**
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
307 *
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.
310 */
311static inline struct drm_crtc_state *
312drm_atomic_get_new_crtc_state(struct drm_atomic_state *state,
313 struct drm_crtc *crtc)
314{
315 return state->crtcs[drm_crtc_index(crtc)].new_state;
316}
317
318/**
Maarten Lankhorst1b26a5e2015-05-13 10:37:25 +0200319 * drm_atomic_get_existing_plane_state - get plane state, if it exists
320 * @state: global atomic state object
321 * @plane: plane to grab
322 *
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.
Maarten Lankhorst21077772017-02-16 15:47:08 +0100325 *
326 * This function is deprecated, @drm_atomic_get_old_plane_state or
327 * @drm_atomic_get_new_plane_state should be used instead.
Maarten Lankhorst1b26a5e2015-05-13 10:37:25 +0200328 */
329static inline struct drm_plane_state *
330drm_atomic_get_existing_plane_state(struct drm_atomic_state *state,
331 struct drm_plane *plane)
332{
Daniel Vetterb8b53422016-06-02 00:06:33 +0200333 return state->planes[drm_plane_index(plane)].state;
Maarten Lankhorst1b26a5e2015-05-13 10:37:25 +0200334}
335
336/**
Maarten Lankhorst21077772017-02-16 15:47:08 +0100337 * drm_atomic_get_old_plane_state - get plane state, if it exists
338 * @state: global atomic state object
339 * @plane: plane to grab
340 *
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.
343 */
344static inline struct drm_plane_state *
345drm_atomic_get_old_plane_state(struct drm_atomic_state *state,
346 struct drm_plane *plane)
347{
348 return state->planes[drm_plane_index(plane)].old_state;
349}
350
351/**
352 * drm_atomic_get_new_plane_state - get plane state, if it exists
353 * @state: global atomic state object
354 * @plane: plane to grab
355 *
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.
358 */
359static inline struct drm_plane_state *
360drm_atomic_get_new_plane_state(struct drm_atomic_state *state,
361 struct drm_plane *plane)
362{
363 return state->planes[drm_plane_index(plane)].new_state;
364}
365
366/**
Maarten Lankhorst1b26a5e2015-05-13 10:37:25 +0200367 * drm_atomic_get_existing_connector_state - get connector state, if it exists
368 * @state: global atomic state object
369 * @connector: connector to grab
370 *
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.
Maarten Lankhorst21077772017-02-16 15:47:08 +0100373 *
374 * This function is deprecated, @drm_atomic_get_old_connector_state or
375 * @drm_atomic_get_new_connector_state should be used instead.
Maarten Lankhorst1b26a5e2015-05-13 10:37:25 +0200376 */
377static inline struct drm_connector_state *
378drm_atomic_get_existing_connector_state(struct drm_atomic_state *state,
379 struct drm_connector *connector)
380{
381 int index = drm_connector_index(connector);
382
383 if (index >= state->num_connector)
384 return NULL;
385
Daniel Vetter63e83c12016-06-02 00:06:32 +0200386 return state->connectors[index].state;
Maarten Lankhorst1b26a5e2015-05-13 10:37:25 +0200387}
388
Daniel Vetter2f196b72016-06-02 16:21:44 +0200389/**
Maarten Lankhorst21077772017-02-16 15:47:08 +0100390 * drm_atomic_get_old_connector_state - get connector state, if it exists
391 * @state: global atomic state object
392 * @connector: connector to grab
393 *
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.
396 */
397static inline struct drm_connector_state *
398drm_atomic_get_old_connector_state(struct drm_atomic_state *state,
399 struct drm_connector *connector)
400{
401 int index = drm_connector_index(connector);
402
403 if (index >= state->num_connector)
404 return NULL;
405
406 return state->connectors[index].old_state;
407}
408
409/**
410 * drm_atomic_get_new_connector_state - get connector state, if it exists
411 * @state: global atomic state object
412 * @connector: connector to grab
413 *
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.
416 */
417static inline struct drm_connector_state *
418drm_atomic_get_new_connector_state(struct drm_atomic_state *state,
419 struct drm_connector *connector)
420{
421 int index = drm_connector_index(connector);
422
423 if (index >= state->num_connector)
424 return NULL;
425
426 return state->connectors[index].new_state;
427}
428
429/**
Daniel Vetter2f196b72016-06-02 16:21:44 +0200430 * __drm_atomic_get_current_plane_state - get current plane state
431 * @state: global atomic state object
432 * @plane: plane to grab
433 *
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.
439 *
440 * WARNING:
441 *
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
Daniel Vetter60c9e1902016-06-02 17:39:14 +0200444 * safe to access the returned state structure through other means. One common
Daniel Vetter2f196b72016-06-02 16:21:44 +0200445 * example is when planes are fixed to a single CRTC, and the driver knows that
Daniel Vetter60c9e1902016-06-02 17:39:14 +0200446 * the CRTC lock is held already. In that case holding the CRTC lock gives a
Daniel Vetter2f196b72016-06-02 16:21:44 +0200447 * 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.
450 *
451 * Returns:
452 *
453 * Read-only pointer to the current plane state.
454 */
455static inline const struct drm_plane_state *
456__drm_atomic_get_current_plane_state(struct drm_atomic_state *state,
457 struct drm_plane *plane)
458{
Daniel Vetterb8b53422016-06-02 00:06:33 +0200459 if (state->planes[drm_plane_index(plane)].state)
460 return state->planes[drm_plane_index(plane)].state;
Daniel Vetter2f196b72016-06-02 16:21:44 +0200461
462 return plane->state;
463}
464
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200465int __must_check
Daniel Stone819364d2015-05-26 14:36:48 +0100466drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,
467 struct drm_display_mode *mode);
468int __must_check
Daniel Stone955f3c32015-05-25 19:11:52 +0100469drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,
470 struct drm_property_blob *blob);
471int __must_check
Daniel Vetter07cc0ef2014-11-27 15:49:39 +0100472drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
473 struct drm_crtc *crtc);
Daniel Vetter321ebf02014-11-04 22:57:27 +0100474void drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
475 struct drm_framebuffer *fb);
Gustavo Padovan13b55662016-11-07 19:03:30 +0900476void drm_atomic_set_fence_for_plane(struct drm_plane_state *plane_state,
477 struct dma_fence *fence);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200478int __must_check
479drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
480 struct drm_crtc *crtc);
481int __must_check
482drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
483 struct drm_crtc *crtc);
Maarten Lankhorste01e9f72015-05-19 16:41:02 +0200484int __must_check
485drm_atomic_add_affected_planes(struct drm_atomic_state *state,
486 struct drm_crtc *crtc);
487
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200488void drm_atomic_legacy_backoff(struct drm_atomic_state *state);
489
Maarten Lankhorst0f45c262015-11-11 11:29:09 +0100490void
491drm_atomic_clean_old_fb(struct drm_device *dev, unsigned plane_mask, int ret);
492
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200493int __must_check drm_atomic_check_only(struct drm_atomic_state *state);
494int __must_check drm_atomic_commit(struct drm_atomic_state *state);
Maarten Lankhorstb837ba02016-04-26 16:11:35 +0200495int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_state *state);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200496
Rob Clark6559c902016-11-05 11:08:10 -0400497void drm_state_dump(struct drm_device *dev, struct drm_printer *p);
498
Daniel Vetterf9a76952017-03-28 17:53:49 +0200499/**
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
505 *
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.
510 *
511 * FIXME:
512 *
513 * Replace all usage of this with one of the explicit iterators below and then
514 * remove this macro.
515 */
Daniel Vetter63e83c12016-06-02 00:06:32 +0200516#define for_each_connector_in_state(__state, connector, connector_state, __i) \
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300517 for ((__i) = 0; \
Daniel Vetter63e83c12016-06-02 00:06:32 +0200518 (__i) < (__state)->num_connector && \
519 ((connector) = (__state)->connectors[__i].ptr, \
520 (connector_state) = (__state)->connectors[__i].state, 1); \
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300521 (__i)++) \
Jani Nikula373701b2015-11-24 21:21:55 +0200522 for_each_if (connector)
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300523
Daniel Vetterf9a76952017-03-28 17:53:49 +0200524/**
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
529 * old state
530 * @new_connector_state: &struct drm_connector_state iteration cursor for the
531 * new state
532 * @__i: int iteration cursor, for macro-internal use
533 *
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.
537 */
Maarten Lankhorst581e49f2017-01-16 10:37:38 +0100538#define for_each_oldnew_connector_in_state(__state, connector, old_connector_state, new_connector_state, __i) \
539 for ((__i) = 0; \
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); \
544 (__i)++) \
545 for_each_if (connector)
546
Daniel Vetterf9a76952017-03-28 17:53:49 +0200547/**
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
552 * old state
553 * @__i: int iteration cursor, for macro-internal use
554 *
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.
558 */
Maarten Lankhorst581e49f2017-01-16 10:37:38 +0100559#define for_each_old_connector_in_state(__state, connector, old_connector_state, __i) \
560 for ((__i) = 0; \
561 (__i) < (__state)->num_connector && \
562 ((connector) = (__state)->connectors[__i].ptr, \
563 (old_connector_state) = (__state)->connectors[__i].old_state, 1); \
564 (__i)++) \
565 for_each_if (connector)
566
Daniel Vetterf9a76952017-03-28 17:53:49 +0200567/**
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
572 * new state
573 * @__i: int iteration cursor, for macro-internal use
574 *
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.
578 */
Maarten Lankhorst581e49f2017-01-16 10:37:38 +0100579#define for_each_new_connector_in_state(__state, connector, new_connector_state, __i) \
580 for ((__i) = 0; \
581 (__i) < (__state)->num_connector && \
582 ((connector) = (__state)->connectors[__i].ptr, \
583 (new_connector_state) = (__state)->connectors[__i].new_state, 1); \
584 (__i)++) \
585 for_each_if (connector)
586
Daniel Vetterf9a76952017-03-28 17:53:49 +0200587/**
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
593 *
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.
598 *
599 * FIXME:
600 *
601 * Replace all usage of this with one of the explicit iterators below and then
602 * remove this macro.
603 */
Daniel Vetter5d943aa62016-06-02 00:06:34 +0200604#define for_each_crtc_in_state(__state, crtc, crtc_state, __i) \
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300605 for ((__i) = 0; \
Daniel Vetter5d943aa62016-06-02 00:06:34 +0200606 (__i) < (__state)->dev->mode_config.num_crtc && \
607 ((crtc) = (__state)->crtcs[__i].ptr, \
608 (crtc_state) = (__state)->crtcs[__i].state, 1); \
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300609 (__i)++) \
Jani Nikula373701b2015-11-24 21:21:55 +0200610 for_each_if (crtc_state)
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +0300611
Daniel Vetterf9a76952017-03-28 17:53:49 +0200612/**
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
619 *
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.
623 */
Maarten Lankhorst581e49f2017-01-16 10:37:38 +0100624#define for_each_oldnew_crtc_in_state(__state, crtc, old_crtc_state, new_crtc_state, __i) \
625 for ((__i) = 0; \
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); \
630 (__i)++) \
631 for_each_if (crtc)
632
Daniel Vetterf9a76952017-03-28 17:53:49 +0200633/**
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
639 *
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.
643 */
Maarten Lankhorst581e49f2017-01-16 10:37:38 +0100644#define for_each_old_crtc_in_state(__state, crtc, old_crtc_state, __i) \
645 for ((__i) = 0; \
646 (__i) < (__state)->dev->mode_config.num_crtc && \
647 ((crtc) = (__state)->crtcs[__i].ptr, \
648 (old_crtc_state) = (__state)->crtcs[__i].old_state, 1); \
649 (__i)++) \
650 for_each_if (crtc)
651
Daniel Vetterf9a76952017-03-28 17:53:49 +0200652/**
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
658 *
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.
662 */
Maarten Lankhorst581e49f2017-01-16 10:37:38 +0100663#define for_each_new_crtc_in_state(__state, crtc, new_crtc_state, __i) \
664 for ((__i) = 0; \
665 (__i) < (__state)->dev->mode_config.num_crtc && \
666 ((crtc) = (__state)->crtcs[__i].ptr, \
667 (new_crtc_state) = (__state)->crtcs[__i].new_state, 1); \
668 (__i)++) \
669 for_each_if (crtc)
670
Daniel Vetterf9a76952017-03-28 17:53:49 +0200671/**
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
677 *
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.
682 *
683 * FIXME:
684 *
685 * Replace all usage of this with one of the explicit iterators below and then
686 * remove this macro.
687 */
Daniel Vetterb8b53422016-06-02 00:06:33 +0200688#define for_each_plane_in_state(__state, plane, plane_state, __i) \
Andrey Ryabinin60f207a2015-05-25 13:29:44 +0300689 for ((__i) = 0; \
Daniel Vetterb8b53422016-06-02 00:06:33 +0200690 (__i) < (__state)->dev->mode_config.num_total_plane && \
691 ((plane) = (__state)->planes[__i].ptr, \
692 (plane_state) = (__state)->planes[__i].state, 1); \
Andrey Ryabinin60f207a2015-05-25 13:29:44 +0300693 (__i)++) \
Jani Nikula373701b2015-11-24 21:21:55 +0200694 for_each_if (plane_state)
Daniel Vetter081e9c02016-06-08 14:18:59 +0200695
Daniel Vetterf9a76952017-03-28 17:53:49 +0200696/**
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
703 *
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.
707 */
Maarten Lankhorst581e49f2017-01-16 10:37:38 +0100708#define for_each_oldnew_plane_in_state(__state, plane, old_plane_state, new_plane_state, __i) \
709 for ((__i) = 0; \
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); \
714 (__i)++) \
715 for_each_if (plane)
716
Daniel Vetterf9a76952017-03-28 17:53:49 +0200717/**
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
723 *
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.
727 */
Maarten Lankhorst581e49f2017-01-16 10:37:38 +0100728#define for_each_old_plane_in_state(__state, plane, old_plane_state, __i) \
729 for ((__i) = 0; \
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); \
733 (__i)++) \
734 for_each_if (plane)
735
Daniel Vetterf9a76952017-03-28 17:53:49 +0200736/**
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
742 *
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.
746 */
Maarten Lankhorst581e49f2017-01-16 10:37:38 +0100747#define for_each_new_plane_in_state(__state, plane, new_plane_state, __i) \
748 for ((__i) = 0; \
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); \
752 (__i)++) \
753 for_each_if (plane)
754
Daniel Vetter081e9c02016-06-08 14:18:59 +0200755/**
756 * drm_atomic_crtc_needs_modeset - compute combined modeset need
757 * @state: &drm_crtc_state for the CRTC
758 *
Daniel Vetterea0dd852016-12-29 21:48:26 +0100759 * To give drivers flexibility &struct drm_crtc_state has 3 booleans to track
Daniel Vetter081e9c02016-06-08 14:18:59 +0200760 * whether the state CRTC changed enough to need a full modeset cycle:
Daniel Vetterf9a76952017-03-28 17:53:49 +0200761 * planes_changed, mode_changed and active_changed. This helper simply
Daniel Vetter081e9c02016-06-08 14:18:59 +0200762 * combines these three to compute the overall need for a modeset for @state.
Brian Starkeyd807ed12016-10-13 10:47:08 +0100763 *
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
767 * possible.
768 *
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
Daniel Vetterd5745282017-01-25 07:26:45 +0100771 * should clear mode_changed in its &drm_mode_config_funcs.atomic_check
772 * implementation.
Daniel Vetter081e9c02016-06-08 14:18:59 +0200773 */
Daniel Vetter2465ff62015-06-18 09:58:55 +0200774static inline bool
Ville Syrjälä79b95552016-11-24 19:47:02 +0200775drm_atomic_crtc_needs_modeset(const struct drm_crtc_state *state)
Daniel Vetter2465ff62015-06-18 09:58:55 +0200776{
Maarten Lankhorstfc596662015-07-21 13:28:57 +0200777 return state->mode_changed || state->active_changed ||
778 state->connectors_changed;
Daniel Vetter2465ff62015-06-18 09:58:55 +0200779}
780
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200781#endif /* DRM_ATOMIC_H_ */