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 31 #include <drm/drm_crtc.h> 32 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 &drm_crtc.commit_list. Protected by 127 * $drm_crtc.commit_lock. 128 */ 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 139 struct __drm_planes_state { 140 struct drm_plane *ptr; 141 struct drm_plane_state *state, *old_state, *new_state; 142 }; 143 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; 150 }; 151 152 struct __drm_connnectors_state { 153 struct drm_connector *ptr; 154 struct drm_connector_state *state, *old_state, *new_state; 155 }; 156 157 /** 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 * @legacy_set_config: Disable conflicting encoders instead of failing with -EINVAL. 164 * @planes: pointer to array of structures with per-plane data 165 * @crtcs: pointer to array of CRTC pointers 166 * @num_connector: size of the @connectors and @connector_states arrays 167 * @connectors: pointer to array of structures with per-connector data 168 * @acquire_ctx: acquire context for this atomic modeset state update 169 */ 170 struct drm_atomic_state { 171 struct kref ref; 172 173 struct drm_device *dev; 174 bool allow_modeset : 1; 175 bool legacy_cursor_update : 1; 176 bool legacy_set_config : 1; 177 struct __drm_planes_state *planes; 178 struct __drm_crtcs_state *crtcs; 179 int num_connector; 180 struct __drm_connnectors_state *connectors; 181 182 struct drm_modeset_acquire_ctx *acquire_ctx; 183 184 /** 185 * @commit_work: 186 * 187 * Work item which can be used by the driver or helpers to execute the 188 * commit without blocking. 189 */ 190 struct work_struct commit_work; 191 }; 192 193 void __drm_crtc_commit_free(struct kref *kref); 194 195 /** 196 * drm_crtc_commit_get - acquire a reference to the CRTC commit 197 * @commit: CRTC commit 198 * 199 * Increases the reference of @commit. 200 */ 201 static inline void drm_crtc_commit_get(struct drm_crtc_commit *commit) 202 { 203 kref_get(&commit->ref); 204 } 205 206 /** 207 * drm_crtc_commit_put - release a reference to the CRTC commmit 208 * @commit: CRTC commit 209 * 210 * This releases a reference to @commit which is freed after removing the 211 * final reference. No locking required and callable from any context. 212 */ 213 static inline void drm_crtc_commit_put(struct drm_crtc_commit *commit) 214 { 215 kref_put(&commit->ref, __drm_crtc_commit_free); 216 } 217 218 struct drm_atomic_state * __must_check 219 drm_atomic_state_alloc(struct drm_device *dev); 220 void drm_atomic_state_clear(struct drm_atomic_state *state); 221 222 /** 223 * drm_atomic_state_get - acquire a reference to the atomic state 224 * @state: The atomic state 225 * 226 * Returns a new reference to the @state 227 */ 228 static inline struct drm_atomic_state * 229 drm_atomic_state_get(struct drm_atomic_state *state) 230 { 231 kref_get(&state->ref); 232 return state; 233 } 234 235 void __drm_atomic_state_free(struct kref *ref); 236 237 /** 238 * drm_atomic_state_put - release a reference to the atomic state 239 * @state: The atomic state 240 * 241 * This releases a reference to @state which is freed after removing the 242 * final reference. No locking required and callable from any context. 243 */ 244 static inline void drm_atomic_state_put(struct drm_atomic_state *state) 245 { 246 kref_put(&state->ref, __drm_atomic_state_free); 247 } 248 249 int __must_check 250 drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state); 251 void drm_atomic_state_default_clear(struct drm_atomic_state *state); 252 void drm_atomic_state_default_release(struct drm_atomic_state *state); 253 254 struct drm_crtc_state * __must_check 255 drm_atomic_get_crtc_state(struct drm_atomic_state *state, 256 struct drm_crtc *crtc); 257 int drm_atomic_crtc_set_property(struct drm_crtc *crtc, 258 struct drm_crtc_state *state, struct drm_property *property, 259 uint64_t val); 260 struct drm_plane_state * __must_check 261 drm_atomic_get_plane_state(struct drm_atomic_state *state, 262 struct drm_plane *plane); 263 int drm_atomic_plane_set_property(struct drm_plane *plane, 264 struct drm_plane_state *state, struct drm_property *property, 265 uint64_t val); 266 struct drm_connector_state * __must_check 267 drm_atomic_get_connector_state(struct drm_atomic_state *state, 268 struct drm_connector *connector); 269 int drm_atomic_connector_set_property(struct drm_connector *connector, 270 struct drm_connector_state *state, struct drm_property *property, 271 uint64_t val); 272 273 /** 274 * drm_atomic_get_existing_crtc_state - get crtc state, if it exists 275 * @state: global atomic state object 276 * @crtc: crtc to grab 277 * 278 * This function returns the crtc state for the given crtc, or NULL 279 * if the crtc is not part of the global atomic state. 280 * 281 * This function is deprecated, @drm_atomic_get_old_crtc_state or 282 * @drm_atomic_get_new_crtc_state should be used instead. 283 */ 284 static inline struct drm_crtc_state * 285 drm_atomic_get_existing_crtc_state(struct drm_atomic_state *state, 286 struct drm_crtc *crtc) 287 { 288 return state->crtcs[drm_crtc_index(crtc)].state; 289 } 290 291 /** 292 * drm_atomic_get_old_crtc_state - get old crtc state, if it exists 293 * @state: global atomic state object 294 * @crtc: crtc to grab 295 * 296 * This function returns the old crtc state for the given crtc, or 297 * NULL if the crtc is not part of the global atomic state. 298 */ 299 static inline struct drm_crtc_state * 300 drm_atomic_get_old_crtc_state(struct drm_atomic_state *state, 301 struct drm_crtc *crtc) 302 { 303 return state->crtcs[drm_crtc_index(crtc)].old_state; 304 } 305 /** 306 * drm_atomic_get_new_crtc_state - get new crtc state, if it exists 307 * @state: global atomic state object 308 * @crtc: crtc to grab 309 * 310 * This function returns the new crtc state for the given crtc, or 311 * NULL if the crtc is not part of the global atomic state. 312 */ 313 static inline struct drm_crtc_state * 314 drm_atomic_get_new_crtc_state(struct drm_atomic_state *state, 315 struct drm_crtc *crtc) 316 { 317 return state->crtcs[drm_crtc_index(crtc)].new_state; 318 } 319 320 /** 321 * drm_atomic_get_existing_plane_state - get plane state, if it exists 322 * @state: global atomic state object 323 * @plane: plane to grab 324 * 325 * This function returns the plane state for the given plane, or NULL 326 * if the plane is not part of the global atomic state. 327 * 328 * This function is deprecated, @drm_atomic_get_old_plane_state or 329 * @drm_atomic_get_new_plane_state should be used instead. 330 */ 331 static inline struct drm_plane_state * 332 drm_atomic_get_existing_plane_state(struct drm_atomic_state *state, 333 struct drm_plane *plane) 334 { 335 return state->planes[drm_plane_index(plane)].state; 336 } 337 338 /** 339 * drm_atomic_get_old_plane_state - get plane state, if it exists 340 * @state: global atomic state object 341 * @plane: plane to grab 342 * 343 * This function returns the old plane state for the given plane, or 344 * NULL if the plane is not part of the global atomic state. 345 */ 346 static inline struct drm_plane_state * 347 drm_atomic_get_old_plane_state(struct drm_atomic_state *state, 348 struct drm_plane *plane) 349 { 350 return state->planes[drm_plane_index(plane)].old_state; 351 } 352 353 /** 354 * drm_atomic_get_new_plane_state - get plane state, if it exists 355 * @state: global atomic state object 356 * @plane: plane to grab 357 * 358 * This function returns the new plane state for the given plane, or 359 * NULL if the plane is not part of the global atomic state. 360 */ 361 static inline struct drm_plane_state * 362 drm_atomic_get_new_plane_state(struct drm_atomic_state *state, 363 struct drm_plane *plane) 364 { 365 return state->planes[drm_plane_index(plane)].new_state; 366 } 367 368 /** 369 * drm_atomic_get_existing_connector_state - get connector state, if it exists 370 * @state: global atomic state object 371 * @connector: connector to grab 372 * 373 * This function returns the connector state for the given connector, 374 * or NULL if the connector is not part of the global atomic state. 375 * 376 * This function is deprecated, @drm_atomic_get_old_connector_state or 377 * @drm_atomic_get_new_connector_state should be used instead. 378 */ 379 static inline struct drm_connector_state * 380 drm_atomic_get_existing_connector_state(struct drm_atomic_state *state, 381 struct drm_connector *connector) 382 { 383 int index = drm_connector_index(connector); 384 385 if (index >= state->num_connector) 386 return NULL; 387 388 return state->connectors[index].state; 389 } 390 391 /** 392 * drm_atomic_get_old_connector_state - get connector state, if it exists 393 * @state: global atomic state object 394 * @connector: connector to grab 395 * 396 * This function returns the old connector state for the given connector, 397 * or NULL if the connector is not part of the global atomic state. 398 */ 399 static inline struct drm_connector_state * 400 drm_atomic_get_old_connector_state(struct drm_atomic_state *state, 401 struct drm_connector *connector) 402 { 403 int index = drm_connector_index(connector); 404 405 if (index >= state->num_connector) 406 return NULL; 407 408 return state->connectors[index].old_state; 409 } 410 411 /** 412 * drm_atomic_get_new_connector_state - get connector state, if it exists 413 * @state: global atomic state object 414 * @connector: connector to grab 415 * 416 * This function returns the new connector state for the given connector, 417 * or NULL if the connector is not part of the global atomic state. 418 */ 419 static inline struct drm_connector_state * 420 drm_atomic_get_new_connector_state(struct drm_atomic_state *state, 421 struct drm_connector *connector) 422 { 423 int index = drm_connector_index(connector); 424 425 if (index >= state->num_connector) 426 return NULL; 427 428 return state->connectors[index].new_state; 429 } 430 431 /** 432 * __drm_atomic_get_current_plane_state - get current plane state 433 * @state: global atomic state object 434 * @plane: plane to grab 435 * 436 * This function returns the plane state for the given plane, either from 437 * @state, or if the plane isn't part of the atomic state update, from @plane. 438 * This is useful in atomic check callbacks, when drivers need to peek at, but 439 * not change, state of other planes, since it avoids threading an error code 440 * back up the call chain. 441 * 442 * WARNING: 443 * 444 * Note that this function is in general unsafe since it doesn't check for the 445 * required locking for access state structures. Drivers must ensure that it is 446 * safe to access the returned state structure through other means. One common 447 * example is when planes are fixed to a single CRTC, and the driver knows that 448 * the CRTC lock is held already. In that case holding the CRTC lock gives a 449 * read-lock on all planes connected to that CRTC. But if planes can be 450 * reassigned things get more tricky. In that case it's better to use 451 * drm_atomic_get_plane_state and wire up full error handling. 452 * 453 * Returns: 454 * 455 * Read-only pointer to the current plane state. 456 */ 457 static inline const struct drm_plane_state * 458 __drm_atomic_get_current_plane_state(struct drm_atomic_state *state, 459 struct drm_plane *plane) 460 { 461 if (state->planes[drm_plane_index(plane)].state) 462 return state->planes[drm_plane_index(plane)].state; 463 464 return plane->state; 465 } 466 467 int __must_check 468 drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state, 469 struct drm_display_mode *mode); 470 int __must_check 471 drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state, 472 struct drm_property_blob *blob); 473 int __must_check 474 drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state, 475 struct drm_crtc *crtc); 476 void drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state, 477 struct drm_framebuffer *fb); 478 void drm_atomic_set_fence_for_plane(struct drm_plane_state *plane_state, 479 struct dma_fence *fence); 480 int __must_check 481 drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state, 482 struct drm_crtc *crtc); 483 int __must_check 484 drm_atomic_add_affected_connectors(struct drm_atomic_state *state, 485 struct drm_crtc *crtc); 486 int __must_check 487 drm_atomic_add_affected_planes(struct drm_atomic_state *state, 488 struct drm_crtc *crtc); 489 490 void drm_atomic_legacy_backoff(struct drm_atomic_state *state); 491 492 void 493 drm_atomic_clean_old_fb(struct drm_device *dev, unsigned plane_mask, int ret); 494 495 int __must_check drm_atomic_check_only(struct drm_atomic_state *state); 496 int __must_check drm_atomic_commit(struct drm_atomic_state *state); 497 int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_state *state); 498 499 void drm_state_dump(struct drm_device *dev, struct drm_printer *p); 500 501 /** 502 * for_each_connector_in_state - iterate over all connectors in an atomic update 503 * @__state: &struct drm_atomic_state pointer 504 * @connector: &struct drm_connector iteration cursor 505 * @connector_state: &struct drm_connector_state iteration cursor 506 * @__i: int iteration cursor, for macro-internal use 507 * 508 * This iterates over all connectors in an atomic update. Note that before the 509 * software state is committed (by calling drm_atomic_helper_swap_state(), this 510 * points to the new state, while afterwards it points to the old state. Due to 511 * this tricky confusion this macro is deprecated. 512 * 513 * FIXME: 514 * 515 * Replace all usage of this with one of the explicit iterators below and then 516 * remove this macro. 517 */ 518 #define for_each_connector_in_state(__state, connector, connector_state, __i) \ 519 for ((__i) = 0; \ 520 (__i) < (__state)->num_connector && \ 521 ((connector) = (__state)->connectors[__i].ptr, \ 522 (connector_state) = (__state)->connectors[__i].state, 1); \ 523 (__i)++) \ 524 for_each_if (connector) 525 526 /** 527 * for_each_oldnew_connector_in_state - iterate over all connectors in an atomic update 528 * @__state: &struct drm_atomic_state pointer 529 * @connector: &struct drm_connector iteration cursor 530 * @old_connector_state: &struct drm_connector_state iteration cursor for the 531 * old state 532 * @new_connector_state: &struct drm_connector_state iteration cursor for the 533 * new state 534 * @__i: int iteration cursor, for macro-internal use 535 * 536 * This iterates over all connectors in an atomic update, tracking both old and 537 * new state. This is useful in places where the state delta needs to be 538 * considered, for example in atomic check functions. 539 */ 540 #define for_each_oldnew_connector_in_state(__state, connector, old_connector_state, new_connector_state, __i) \ 541 for ((__i) = 0; \ 542 (__i) < (__state)->num_connector && \ 543 ((connector) = (__state)->connectors[__i].ptr, \ 544 (old_connector_state) = (__state)->connectors[__i].old_state, \ 545 (new_connector_state) = (__state)->connectors[__i].new_state, 1); \ 546 (__i)++) \ 547 for_each_if (connector) 548 549 /** 550 * for_each_old_connector_in_state - iterate over all connectors in an atomic update 551 * @__state: &struct drm_atomic_state pointer 552 * @connector: &struct drm_connector iteration cursor 553 * @old_connector_state: &struct drm_connector_state iteration cursor for the 554 * old state 555 * @__i: int iteration cursor, for macro-internal use 556 * 557 * This iterates over all connectors in an atomic update, tracking only the old 558 * state. This is useful in disable functions, where we need the old state the 559 * hardware is still in. 560 */ 561 #define for_each_old_connector_in_state(__state, connector, old_connector_state, __i) \ 562 for ((__i) = 0; \ 563 (__i) < (__state)->num_connector && \ 564 ((connector) = (__state)->connectors[__i].ptr, \ 565 (old_connector_state) = (__state)->connectors[__i].old_state, 1); \ 566 (__i)++) \ 567 for_each_if (connector) 568 569 /** 570 * for_each_new_connector_in_state - iterate over all connectors in an atomic update 571 * @__state: &struct drm_atomic_state pointer 572 * @connector: &struct drm_connector iteration cursor 573 * @new_connector_state: &struct drm_connector_state iteration cursor for the 574 * new state 575 * @__i: int iteration cursor, for macro-internal use 576 * 577 * This iterates over all connectors in an atomic update, tracking only the new 578 * state. This is useful in enable functions, where we need the new state the 579 * hardware should be in when the atomic commit operation has completed. 580 */ 581 #define for_each_new_connector_in_state(__state, connector, new_connector_state, __i) \ 582 for ((__i) = 0; \ 583 (__i) < (__state)->num_connector && \ 584 ((connector) = (__state)->connectors[__i].ptr, \ 585 (new_connector_state) = (__state)->connectors[__i].new_state, 1); \ 586 (__i)++) \ 587 for_each_if (connector) 588 589 /** 590 * for_each_crtc_in_state - iterate over all connectors in an atomic update 591 * @__state: &struct drm_atomic_state pointer 592 * @crtc: &struct drm_crtc iteration cursor 593 * @crtc_state: &struct drm_crtc_state iteration cursor 594 * @__i: int iteration cursor, for macro-internal use 595 * 596 * This iterates over all CRTCs in an atomic update. Note that before the 597 * software state is committed (by calling drm_atomic_helper_swap_state(), this 598 * points to the new state, while afterwards it points to the old state. Due to 599 * this tricky confusion this macro is deprecated. 600 * 601 * FIXME: 602 * 603 * Replace all usage of this with one of the explicit iterators below and then 604 * remove this macro. 605 */ 606 #define for_each_crtc_in_state(__state, crtc, crtc_state, __i) \ 607 for ((__i) = 0; \ 608 (__i) < (__state)->dev->mode_config.num_crtc && \ 609 ((crtc) = (__state)->crtcs[__i].ptr, \ 610 (crtc_state) = (__state)->crtcs[__i].state, 1); \ 611 (__i)++) \ 612 for_each_if (crtc_state) 613 614 /** 615 * for_each_oldnew_crtc_in_state - iterate over all CRTCs in an atomic update 616 * @__state: &struct drm_atomic_state pointer 617 * @crtc: &struct drm_crtc iteration cursor 618 * @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state 619 * @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state 620 * @__i: int iteration cursor, for macro-internal use 621 * 622 * This iterates over all CRTCs in an atomic update, tracking both old and 623 * new state. This is useful in places where the state delta needs to be 624 * considered, for example in atomic check functions. 625 */ 626 #define for_each_oldnew_crtc_in_state(__state, crtc, old_crtc_state, new_crtc_state, __i) \ 627 for ((__i) = 0; \ 628 (__i) < (__state)->dev->mode_config.num_crtc && \ 629 ((crtc) = (__state)->crtcs[__i].ptr, \ 630 (old_crtc_state) = (__state)->crtcs[__i].old_state, \ 631 (new_crtc_state) = (__state)->crtcs[__i].new_state, 1); \ 632 (__i)++) \ 633 for_each_if (crtc) 634 635 /** 636 * for_each_old_crtc_in_state - iterate over all CRTCs in an atomic update 637 * @__state: &struct drm_atomic_state pointer 638 * @crtc: &struct drm_crtc iteration cursor 639 * @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state 640 * @__i: int iteration cursor, for macro-internal use 641 * 642 * This iterates over all CRTCs in an atomic update, tracking only the old 643 * state. This is useful in disable functions, where we need the old state the 644 * hardware is still in. 645 */ 646 #define for_each_old_crtc_in_state(__state, crtc, old_crtc_state, __i) \ 647 for ((__i) = 0; \ 648 (__i) < (__state)->dev->mode_config.num_crtc && \ 649 ((crtc) = (__state)->crtcs[__i].ptr, \ 650 (old_crtc_state) = (__state)->crtcs[__i].old_state, 1); \ 651 (__i)++) \ 652 for_each_if (crtc) 653 654 /** 655 * for_each_new_crtc_in_state - iterate over all CRTCs in an atomic update 656 * @__state: &struct drm_atomic_state pointer 657 * @crtc: &struct drm_crtc iteration cursor 658 * @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state 659 * @__i: int iteration cursor, for macro-internal use 660 * 661 * This iterates over all CRTCs in an atomic update, tracking only the new 662 * state. This is useful in enable functions, where we need the new state the 663 * hardware should be in when the atomic commit operation has completed. 664 */ 665 #define for_each_new_crtc_in_state(__state, crtc, new_crtc_state, __i) \ 666 for ((__i) = 0; \ 667 (__i) < (__state)->dev->mode_config.num_crtc && \ 668 ((crtc) = (__state)->crtcs[__i].ptr, \ 669 (new_crtc_state) = (__state)->crtcs[__i].new_state, 1); \ 670 (__i)++) \ 671 for_each_if (crtc) 672 673 /** 674 * for_each_plane_in_state - iterate over all planes in an atomic update 675 * @__state: &struct drm_atomic_state pointer 676 * @plane: &struct drm_plane iteration cursor 677 * @plane_state: &struct drm_plane_state iteration cursor 678 * @__i: int iteration cursor, for macro-internal use 679 * 680 * This iterates over all planes in an atomic update. Note that before the 681 * software state is committed (by calling drm_atomic_helper_swap_state(), this 682 * points to the new state, while afterwards it points to the old state. Due to 683 * this tricky confusion this macro is deprecated. 684 * 685 * FIXME: 686 * 687 * Replace all usage of this with one of the explicit iterators below and then 688 * remove this macro. 689 */ 690 #define for_each_plane_in_state(__state, plane, plane_state, __i) \ 691 for ((__i) = 0; \ 692 (__i) < (__state)->dev->mode_config.num_total_plane && \ 693 ((plane) = (__state)->planes[__i].ptr, \ 694 (plane_state) = (__state)->planes[__i].state, 1); \ 695 (__i)++) \ 696 for_each_if (plane_state) 697 698 /** 699 * for_each_oldnew_plane_in_state - iterate over all planes in an atomic update 700 * @__state: &struct drm_atomic_state pointer 701 * @plane: &struct drm_plane iteration cursor 702 * @old_plane_state: &struct drm_plane_state iteration cursor for the old state 703 * @new_plane_state: &struct drm_plane_state iteration cursor for the new state 704 * @__i: int iteration cursor, for macro-internal use 705 * 706 * This iterates over all planes in an atomic update, tracking both old and 707 * new state. This is useful in places where the state delta needs to be 708 * considered, for example in atomic check functions. 709 */ 710 #define for_each_oldnew_plane_in_state(__state, plane, old_plane_state, new_plane_state, __i) \ 711 for ((__i) = 0; \ 712 (__i) < (__state)->dev->mode_config.num_total_plane && \ 713 ((plane) = (__state)->planes[__i].ptr, \ 714 (old_plane_state) = (__state)->planes[__i].old_state, \ 715 (new_plane_state) = (__state)->planes[__i].new_state, 1); \ 716 (__i)++) \ 717 for_each_if (plane) 718 719 /** 720 * for_each_old_plane_in_state - iterate over all planes in an atomic update 721 * @__state: &struct drm_atomic_state pointer 722 * @plane: &struct drm_plane iteration cursor 723 * @old_plane_state: &struct drm_plane_state iteration cursor for the old state 724 * @__i: int iteration cursor, for macro-internal use 725 * 726 * This iterates over all planes in an atomic update, tracking only the old 727 * state. This is useful in disable functions, where we need the old state the 728 * hardware is still in. 729 */ 730 #define for_each_old_plane_in_state(__state, plane, old_plane_state, __i) \ 731 for ((__i) = 0; \ 732 (__i) < (__state)->dev->mode_config.num_total_plane && \ 733 ((plane) = (__state)->planes[__i].ptr, \ 734 (old_plane_state) = (__state)->planes[__i].old_state, 1); \ 735 (__i)++) \ 736 for_each_if (plane) 737 738 /** 739 * for_each_new_plane_in_state - iterate over all planes in an atomic update 740 * @__state: &struct drm_atomic_state pointer 741 * @plane: &struct drm_plane iteration cursor 742 * @new_plane_state: &struct drm_plane_state iteration cursor for the new state 743 * @__i: int iteration cursor, for macro-internal use 744 * 745 * This iterates over all planes in an atomic update, tracking only the new 746 * state. This is useful in enable functions, where we need the new state the 747 * hardware should be in when the atomic commit operation has completed. 748 */ 749 #define for_each_new_plane_in_state(__state, plane, new_plane_state, __i) \ 750 for ((__i) = 0; \ 751 (__i) < (__state)->dev->mode_config.num_total_plane && \ 752 ((plane) = (__state)->planes[__i].ptr, \ 753 (new_plane_state) = (__state)->planes[__i].new_state, 1); \ 754 (__i)++) \ 755 for_each_if (plane) 756 757 /** 758 * drm_atomic_crtc_needs_modeset - compute combined modeset need 759 * @state: &drm_crtc_state for the CRTC 760 * 761 * To give drivers flexibility &struct drm_crtc_state has 3 booleans to track 762 * whether the state CRTC changed enough to need a full modeset cycle: 763 * planes_changed, mode_changed and active_changed. This helper simply 764 * combines these three to compute the overall need for a modeset for @state. 765 * 766 * The atomic helper code sets these booleans, but drivers can and should 767 * change them appropriately to accurately represent whether a modeset is 768 * really needed. In general, drivers should avoid full modesets whenever 769 * possible. 770 * 771 * For example if the CRTC mode has changed, and the hardware is able to enact 772 * the requested mode change without going through a full modeset, the driver 773 * should clear mode_changed in its &drm_mode_config_funcs.atomic_check 774 * implementation. 775 */ 776 static inline bool 777 drm_atomic_crtc_needs_modeset(const struct drm_crtc_state *state) 778 { 779 return state->mode_changed || state->active_changed || 780 state->connectors_changed; 781 } 782 783 #endif /* DRM_ATOMIC_H_ */ 784