Daniel Vetter | cc4ceb4 | 2014-07-25 21:30:38 +0200 | [diff] [blame] | 1 | /* |
| 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 Reding | 37cc014 | 2014-11-25 12:09:48 +0100 | [diff] [blame] | 31 | #include <drm/drm_crtc.h> |
| 32 | |
Daniel Vetter | 43968d7 | 2016-09-21 10:59:24 +0200 | [diff] [blame] | 33 | /** |
| 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 | */ |
| 69 | struct 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 | * |
| 126 | * Entry on the per-CRTC commit_list. Protected by crtc->commit_lock. |
| 127 | */ |
| 128 | struct list_head commit_entry; |
| 129 | |
| 130 | /** |
| 131 | * @event: |
| 132 | * |
| 133 | * &drm_pending_vblank_event pointer to clean up private events. |
| 134 | */ |
| 135 | struct drm_pending_vblank_event *event; |
| 136 | }; |
| 137 | |
| 138 | struct __drm_planes_state { |
| 139 | struct drm_plane *ptr; |
| 140 | struct drm_plane_state *state; |
| 141 | }; |
| 142 | |
| 143 | struct __drm_crtcs_state { |
| 144 | struct drm_crtc *ptr; |
| 145 | struct drm_crtc_state *state; |
| 146 | struct drm_crtc_commit *commit; |
Gustavo Padovan | 7e9081c | 2017-01-13 12:22:09 -0200 | [diff] [blame^] | 147 | s32 __user *out_fence_ptr; |
Daniel Vetter | 43968d7 | 2016-09-21 10:59:24 +0200 | [diff] [blame] | 148 | }; |
| 149 | |
| 150 | struct __drm_connnectors_state { |
| 151 | struct drm_connector *ptr; |
| 152 | struct drm_connector_state *state; |
| 153 | }; |
| 154 | |
| 155 | /** |
| 156 | * struct drm_atomic_state - the global state object for atomic updates |
Chris Wilson | 0853695 | 2016-10-14 13:18:18 +0100 | [diff] [blame] | 157 | * @ref: count of all references to this state (will not be freed until zero) |
Daniel Vetter | 43968d7 | 2016-09-21 10:59:24 +0200 | [diff] [blame] | 158 | * @dev: parent DRM device |
| 159 | * @allow_modeset: allow full modeset |
| 160 | * @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics |
| 161 | * @legacy_set_config: Disable conflicting encoders instead of failing with -EINVAL. |
| 162 | * @planes: pointer to array of structures with per-plane data |
| 163 | * @crtcs: pointer to array of CRTC pointers |
| 164 | * @num_connector: size of the @connectors and @connector_states arrays |
| 165 | * @connectors: pointer to array of structures with per-connector data |
| 166 | * @acquire_ctx: acquire context for this atomic modeset state update |
| 167 | */ |
| 168 | struct drm_atomic_state { |
Chris Wilson | 0853695 | 2016-10-14 13:18:18 +0100 | [diff] [blame] | 169 | struct kref ref; |
| 170 | |
Daniel Vetter | 43968d7 | 2016-09-21 10:59:24 +0200 | [diff] [blame] | 171 | struct drm_device *dev; |
| 172 | bool allow_modeset : 1; |
| 173 | bool legacy_cursor_update : 1; |
| 174 | bool legacy_set_config : 1; |
| 175 | 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 Vetter | 3b24f7d | 2016-06-08 14:19:00 +0200 | [diff] [blame] | 191 | void drm_crtc_commit_put(struct drm_crtc_commit *commit); |
| 192 | static inline void drm_crtc_commit_get(struct drm_crtc_commit *commit) |
| 193 | { |
| 194 | kref_get(&commit->ref); |
| 195 | } |
| 196 | |
Daniel Vetter | cc4ceb4 | 2014-07-25 21:30:38 +0200 | [diff] [blame] | 197 | struct drm_atomic_state * __must_check |
| 198 | drm_atomic_state_alloc(struct drm_device *dev); |
| 199 | void drm_atomic_state_clear(struct drm_atomic_state *state); |
Chris Wilson | 0853695 | 2016-10-14 13:18:18 +0100 | [diff] [blame] | 200 | |
| 201 | /** |
| 202 | * drm_atomic_state_get - acquire a reference to the atomic state |
| 203 | * @state: The atomic state |
| 204 | * |
| 205 | * Returns a new reference to the @state |
| 206 | */ |
| 207 | static inline struct drm_atomic_state * |
| 208 | drm_atomic_state_get(struct drm_atomic_state *state) |
| 209 | { |
| 210 | kref_get(&state->ref); |
| 211 | return state; |
| 212 | } |
| 213 | |
| 214 | void __drm_atomic_state_free(struct kref *ref); |
| 215 | |
| 216 | /** |
| 217 | * drm_atomic_state_put - release a reference to the atomic state |
| 218 | * @state: The atomic state |
| 219 | * |
| 220 | * This releases a reference to @state which is freed after removing the |
| 221 | * final reference. No locking required and callable from any context. |
| 222 | */ |
| 223 | static inline void drm_atomic_state_put(struct drm_atomic_state *state) |
| 224 | { |
| 225 | kref_put(&state->ref, __drm_atomic_state_free); |
| 226 | } |
Daniel Vetter | cc4ceb4 | 2014-07-25 21:30:38 +0200 | [diff] [blame] | 227 | |
Maarten Lankhorst | 036ef57 | 2015-05-18 10:06:40 +0200 | [diff] [blame] | 228 | int __must_check |
| 229 | drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state); |
| 230 | void drm_atomic_state_default_clear(struct drm_atomic_state *state); |
| 231 | void drm_atomic_state_default_release(struct drm_atomic_state *state); |
| 232 | |
Daniel Vetter | cc4ceb4 | 2014-07-25 21:30:38 +0200 | [diff] [blame] | 233 | struct drm_crtc_state * __must_check |
| 234 | drm_atomic_get_crtc_state(struct drm_atomic_state *state, |
| 235 | struct drm_crtc *crtc); |
Rob Clark | 40ecc69 | 2014-12-18 16:01:46 -0500 | [diff] [blame] | 236 | int drm_atomic_crtc_set_property(struct drm_crtc *crtc, |
| 237 | struct drm_crtc_state *state, struct drm_property *property, |
| 238 | uint64_t val); |
Daniel Vetter | cc4ceb4 | 2014-07-25 21:30:38 +0200 | [diff] [blame] | 239 | struct drm_plane_state * __must_check |
| 240 | drm_atomic_get_plane_state(struct drm_atomic_state *state, |
| 241 | struct drm_plane *plane); |
Rob Clark | 40ecc69 | 2014-12-18 16:01:46 -0500 | [diff] [blame] | 242 | int drm_atomic_plane_set_property(struct drm_plane *plane, |
| 243 | struct drm_plane_state *state, struct drm_property *property, |
| 244 | uint64_t val); |
Daniel Vetter | cc4ceb4 | 2014-07-25 21:30:38 +0200 | [diff] [blame] | 245 | struct drm_connector_state * __must_check |
| 246 | drm_atomic_get_connector_state(struct drm_atomic_state *state, |
| 247 | struct drm_connector *connector); |
Rob Clark | 40ecc69 | 2014-12-18 16:01:46 -0500 | [diff] [blame] | 248 | int drm_atomic_connector_set_property(struct drm_connector *connector, |
| 249 | struct drm_connector_state *state, struct drm_property *property, |
| 250 | uint64_t val); |
Rob Clark | 88a48e2 | 2014-12-18 16:01:50 -0500 | [diff] [blame] | 251 | |
Maarten Lankhorst | 1b26a5e | 2015-05-13 10:37:25 +0200 | [diff] [blame] | 252 | /** |
| 253 | * drm_atomic_get_existing_crtc_state - get crtc state, if it exists |
| 254 | * @state: global atomic state object |
| 255 | * @crtc: crtc to grab |
| 256 | * |
| 257 | * This function returns the crtc state for the given crtc, or NULL |
| 258 | * if the crtc is not part of the global atomic state. |
| 259 | */ |
| 260 | static inline struct drm_crtc_state * |
| 261 | drm_atomic_get_existing_crtc_state(struct drm_atomic_state *state, |
| 262 | struct drm_crtc *crtc) |
| 263 | { |
Daniel Vetter | 5d943aa6 | 2016-06-02 00:06:34 +0200 | [diff] [blame] | 264 | return state->crtcs[drm_crtc_index(crtc)].state; |
Maarten Lankhorst | 1b26a5e | 2015-05-13 10:37:25 +0200 | [diff] [blame] | 265 | } |
| 266 | |
| 267 | /** |
| 268 | * drm_atomic_get_existing_plane_state - get plane state, if it exists |
| 269 | * @state: global atomic state object |
| 270 | * @plane: plane to grab |
| 271 | * |
| 272 | * This function returns the plane state for the given plane, or NULL |
| 273 | * if the plane is not part of the global atomic state. |
| 274 | */ |
| 275 | static inline struct drm_plane_state * |
| 276 | drm_atomic_get_existing_plane_state(struct drm_atomic_state *state, |
| 277 | struct drm_plane *plane) |
| 278 | { |
Daniel Vetter | b8b5342 | 2016-06-02 00:06:33 +0200 | [diff] [blame] | 279 | return state->planes[drm_plane_index(plane)].state; |
Maarten Lankhorst | 1b26a5e | 2015-05-13 10:37:25 +0200 | [diff] [blame] | 280 | } |
| 281 | |
| 282 | /** |
| 283 | * drm_atomic_get_existing_connector_state - get connector state, if it exists |
| 284 | * @state: global atomic state object |
| 285 | * @connector: connector to grab |
| 286 | * |
| 287 | * This function returns the connector state for the given connector, |
| 288 | * or NULL if the connector is not part of the global atomic state. |
| 289 | */ |
| 290 | static inline struct drm_connector_state * |
| 291 | drm_atomic_get_existing_connector_state(struct drm_atomic_state *state, |
| 292 | struct drm_connector *connector) |
| 293 | { |
| 294 | int index = drm_connector_index(connector); |
| 295 | |
| 296 | if (index >= state->num_connector) |
| 297 | return NULL; |
| 298 | |
Daniel Vetter | 63e83c1 | 2016-06-02 00:06:32 +0200 | [diff] [blame] | 299 | return state->connectors[index].state; |
Maarten Lankhorst | 1b26a5e | 2015-05-13 10:37:25 +0200 | [diff] [blame] | 300 | } |
| 301 | |
Daniel Vetter | 2f196b7 | 2016-06-02 16:21:44 +0200 | [diff] [blame] | 302 | /** |
| 303 | * __drm_atomic_get_current_plane_state - get current plane state |
| 304 | * @state: global atomic state object |
| 305 | * @plane: plane to grab |
| 306 | * |
| 307 | * This function returns the plane state for the given plane, either from |
| 308 | * @state, or if the plane isn't part of the atomic state update, from @plane. |
| 309 | * This is useful in atomic check callbacks, when drivers need to peek at, but |
| 310 | * not change, state of other planes, since it avoids threading an error code |
| 311 | * back up the call chain. |
| 312 | * |
| 313 | * WARNING: |
| 314 | * |
| 315 | * Note that this function is in general unsafe since it doesn't check for the |
| 316 | * required locking for access state structures. Drivers must ensure that it is |
Daniel Vetter | 60c9e190 | 2016-06-02 17:39:14 +0200 | [diff] [blame] | 317 | * safe to access the returned state structure through other means. One common |
Daniel Vetter | 2f196b7 | 2016-06-02 16:21:44 +0200 | [diff] [blame] | 318 | * example is when planes are fixed to a single CRTC, and the driver knows that |
Daniel Vetter | 60c9e190 | 2016-06-02 17:39:14 +0200 | [diff] [blame] | 319 | * the CRTC lock is held already. In that case holding the CRTC lock gives a |
Daniel Vetter | 2f196b7 | 2016-06-02 16:21:44 +0200 | [diff] [blame] | 320 | * read-lock on all planes connected to that CRTC. But if planes can be |
| 321 | * reassigned things get more tricky. In that case it's better to use |
| 322 | * drm_atomic_get_plane_state and wire up full error handling. |
| 323 | * |
| 324 | * Returns: |
| 325 | * |
| 326 | * Read-only pointer to the current plane state. |
| 327 | */ |
| 328 | static inline const struct drm_plane_state * |
| 329 | __drm_atomic_get_current_plane_state(struct drm_atomic_state *state, |
| 330 | struct drm_plane *plane) |
| 331 | { |
Daniel Vetter | b8b5342 | 2016-06-02 00:06:33 +0200 | [diff] [blame] | 332 | if (state->planes[drm_plane_index(plane)].state) |
| 333 | return state->planes[drm_plane_index(plane)].state; |
Daniel Vetter | 2f196b7 | 2016-06-02 16:21:44 +0200 | [diff] [blame] | 334 | |
| 335 | return plane->state; |
| 336 | } |
| 337 | |
Daniel Vetter | cc4ceb4 | 2014-07-25 21:30:38 +0200 | [diff] [blame] | 338 | int __must_check |
Daniel Stone | 819364d | 2015-05-26 14:36:48 +0100 | [diff] [blame] | 339 | drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state, |
| 340 | struct drm_display_mode *mode); |
| 341 | int __must_check |
Daniel Stone | 955f3c3 | 2015-05-25 19:11:52 +0100 | [diff] [blame] | 342 | drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state, |
| 343 | struct drm_property_blob *blob); |
| 344 | int __must_check |
Daniel Vetter | 07cc0ef | 2014-11-27 15:49:39 +0100 | [diff] [blame] | 345 | drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state, |
| 346 | struct drm_crtc *crtc); |
Daniel Vetter | 321ebf0 | 2014-11-04 22:57:27 +0100 | [diff] [blame] | 347 | void drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state, |
| 348 | struct drm_framebuffer *fb); |
Gustavo Padovan | 13b5566 | 2016-11-07 19:03:30 +0900 | [diff] [blame] | 349 | void drm_atomic_set_fence_for_plane(struct drm_plane_state *plane_state, |
| 350 | struct dma_fence *fence); |
Daniel Vetter | cc4ceb4 | 2014-07-25 21:30:38 +0200 | [diff] [blame] | 351 | int __must_check |
| 352 | drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state, |
| 353 | struct drm_crtc *crtc); |
| 354 | int __must_check |
| 355 | drm_atomic_add_affected_connectors(struct drm_atomic_state *state, |
| 356 | struct drm_crtc *crtc); |
Maarten Lankhorst | e01e9f7 | 2015-05-19 16:41:02 +0200 | [diff] [blame] | 357 | int __must_check |
| 358 | drm_atomic_add_affected_planes(struct drm_atomic_state *state, |
| 359 | struct drm_crtc *crtc); |
| 360 | |
Daniel Vetter | cc4ceb4 | 2014-07-25 21:30:38 +0200 | [diff] [blame] | 361 | void drm_atomic_legacy_backoff(struct drm_atomic_state *state); |
| 362 | |
Maarten Lankhorst | 0f45c26 | 2015-11-11 11:29:09 +0100 | [diff] [blame] | 363 | void |
| 364 | drm_atomic_clean_old_fb(struct drm_device *dev, unsigned plane_mask, int ret); |
| 365 | |
Daniel Vetter | cc4ceb4 | 2014-07-25 21:30:38 +0200 | [diff] [blame] | 366 | int __must_check drm_atomic_check_only(struct drm_atomic_state *state); |
| 367 | int __must_check drm_atomic_commit(struct drm_atomic_state *state); |
Maarten Lankhorst | b837ba0 | 2016-04-26 16:11:35 +0200 | [diff] [blame] | 368 | int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_state *state); |
Daniel Vetter | cc4ceb4 | 2014-07-25 21:30:38 +0200 | [diff] [blame] | 369 | |
Rob Clark | 6559c90 | 2016-11-05 11:08:10 -0400 | [diff] [blame] | 370 | void drm_state_dump(struct drm_device *dev, struct drm_printer *p); |
| 371 | |
| 372 | #ifdef CONFIG_DEBUG_FS |
| 373 | struct drm_minor; |
| 374 | int drm_atomic_debugfs_init(struct drm_minor *minor); |
Liviu Dudau | 8c0b55e | 2016-11-17 11:41:29 +0000 | [diff] [blame] | 375 | int drm_atomic_debugfs_cleanup(struct drm_minor *minor); |
Rob Clark | 6559c90 | 2016-11-05 11:08:10 -0400 | [diff] [blame] | 376 | #endif |
| 377 | |
Daniel Vetter | 63e83c1 | 2016-06-02 00:06:32 +0200 | [diff] [blame] | 378 | #define for_each_connector_in_state(__state, connector, connector_state, __i) \ |
Ander Conselvan de Oliveira | df63b99 | 2015-04-10 14:58:39 +0300 | [diff] [blame] | 379 | for ((__i) = 0; \ |
Daniel Vetter | 63e83c1 | 2016-06-02 00:06:32 +0200 | [diff] [blame] | 380 | (__i) < (__state)->num_connector && \ |
| 381 | ((connector) = (__state)->connectors[__i].ptr, \ |
| 382 | (connector_state) = (__state)->connectors[__i].state, 1); \ |
Ander Conselvan de Oliveira | df63b99 | 2015-04-10 14:58:39 +0300 | [diff] [blame] | 383 | (__i)++) \ |
Jani Nikula | 373701b | 2015-11-24 21:21:55 +0200 | [diff] [blame] | 384 | for_each_if (connector) |
Ander Conselvan de Oliveira | df63b99 | 2015-04-10 14:58:39 +0300 | [diff] [blame] | 385 | |
Daniel Vetter | 5d943aa6 | 2016-06-02 00:06:34 +0200 | [diff] [blame] | 386 | #define for_each_crtc_in_state(__state, crtc, crtc_state, __i) \ |
Ander Conselvan de Oliveira | df63b99 | 2015-04-10 14:58:39 +0300 | [diff] [blame] | 387 | for ((__i) = 0; \ |
Daniel Vetter | 5d943aa6 | 2016-06-02 00:06:34 +0200 | [diff] [blame] | 388 | (__i) < (__state)->dev->mode_config.num_crtc && \ |
| 389 | ((crtc) = (__state)->crtcs[__i].ptr, \ |
| 390 | (crtc_state) = (__state)->crtcs[__i].state, 1); \ |
Ander Conselvan de Oliveira | df63b99 | 2015-04-10 14:58:39 +0300 | [diff] [blame] | 391 | (__i)++) \ |
Jani Nikula | 373701b | 2015-11-24 21:21:55 +0200 | [diff] [blame] | 392 | for_each_if (crtc_state) |
Ander Conselvan de Oliveira | df63b99 | 2015-04-10 14:58:39 +0300 | [diff] [blame] | 393 | |
Daniel Vetter | b8b5342 | 2016-06-02 00:06:33 +0200 | [diff] [blame] | 394 | #define for_each_plane_in_state(__state, plane, plane_state, __i) \ |
Andrey Ryabinin | 60f207a | 2015-05-25 13:29:44 +0300 | [diff] [blame] | 395 | for ((__i) = 0; \ |
Daniel Vetter | b8b5342 | 2016-06-02 00:06:33 +0200 | [diff] [blame] | 396 | (__i) < (__state)->dev->mode_config.num_total_plane && \ |
| 397 | ((plane) = (__state)->planes[__i].ptr, \ |
| 398 | (plane_state) = (__state)->planes[__i].state, 1); \ |
Andrey Ryabinin | 60f207a | 2015-05-25 13:29:44 +0300 | [diff] [blame] | 399 | (__i)++) \ |
Jani Nikula | 373701b | 2015-11-24 21:21:55 +0200 | [diff] [blame] | 400 | for_each_if (plane_state) |
Daniel Vetter | 081e9c0 | 2016-06-08 14:18:59 +0200 | [diff] [blame] | 401 | |
| 402 | /** |
| 403 | * drm_atomic_crtc_needs_modeset - compute combined modeset need |
| 404 | * @state: &drm_crtc_state for the CRTC |
| 405 | * |
| 406 | * To give drivers flexibility struct &drm_crtc_state has 3 booleans to track |
| 407 | * whether the state CRTC changed enough to need a full modeset cycle: |
Brian Starkey | d807ed1 | 2016-10-13 10:47:08 +0100 | [diff] [blame] | 408 | * connectors_changed, mode_changed and active_changed. This helper simply |
Daniel Vetter | 081e9c0 | 2016-06-08 14:18:59 +0200 | [diff] [blame] | 409 | * combines these three to compute the overall need for a modeset for @state. |
Brian Starkey | d807ed1 | 2016-10-13 10:47:08 +0100 | [diff] [blame] | 410 | * |
| 411 | * The atomic helper code sets these booleans, but drivers can and should |
| 412 | * change them appropriately to accurately represent whether a modeset is |
| 413 | * really needed. In general, drivers should avoid full modesets whenever |
| 414 | * possible. |
| 415 | * |
| 416 | * For example if the CRTC mode has changed, and the hardware is able to enact |
| 417 | * the requested mode change without going through a full modeset, the driver |
| 418 | * should clear mode_changed during its ->atomic_check. |
Daniel Vetter | 081e9c0 | 2016-06-08 14:18:59 +0200 | [diff] [blame] | 419 | */ |
Daniel Vetter | 2465ff6 | 2015-06-18 09:58:55 +0200 | [diff] [blame] | 420 | static inline bool |
Ville Syrjälä | 79b9555 | 2016-11-24 19:47:02 +0200 | [diff] [blame] | 421 | drm_atomic_crtc_needs_modeset(const struct drm_crtc_state *state) |
Daniel Vetter | 2465ff6 | 2015-06-18 09:58:55 +0200 | [diff] [blame] | 422 | { |
Maarten Lankhorst | fc59666 | 2015-07-21 13:28:57 +0200 | [diff] [blame] | 423 | return state->mode_changed || state->active_changed || |
| 424 | state->connectors_changed; |
Daniel Vetter | 2465ff6 | 2015-06-18 09:58:55 +0200 | [diff] [blame] | 425 | } |
| 426 | |
Ander Conselvan de Oliveira | df63b99 | 2015-04-10 14:58:39 +0300 | [diff] [blame] | 427 | |
Daniel Vetter | cc4ceb4 | 2014-07-25 21:30:38 +0200 | [diff] [blame] | 428 | #endif /* DRM_ATOMIC_H_ */ |