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 * @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 */ 169 struct drm_atomic_state { 170 struct kref ref; 171 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; 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 191 void __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 */ 199 static inline void drm_crtc_commit_get(struct drm_crtc_commit *commit) 200 { 201 kref_get(&commit->ref); 202 } 203 204 /** 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 */ 211 static inline void drm_crtc_commit_put(struct drm_crtc_commit *commit) 212 { 213 kref_put(&commit->ref, __drm_crtc_commit_free); 214 } 215 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); 219 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 */ 226 static inline struct drm_atomic_state * 227 drm_atomic_state_get(struct drm_atomic_state *state) 228 { 229 kref_get(&state->ref); 230 return state; 231 } 232 233 void __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 */ 242 static inline void drm_atomic_state_put(struct drm_atomic_state *state) 243 { 244 kref_put(&state->ref, __drm_atomic_state_free); 245 } 246 247 int __must_check 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); 251 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, 257 uint64_t val); 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, 263 uint64_t val); 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, 269 uint64_t val); 270 271 /** 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. 278 * 279 * This function is deprecated, @drm_atomic_get_old_crtc_state or 280 * @drm_atomic_get_new_crtc_state should be used instead. 281 */ 282 static inline struct drm_crtc_state * 283 drm_atomic_get_existing_crtc_state(struct drm_atomic_state *state, 284 struct drm_crtc *crtc) 285 { 286 return state->crtcs[drm_crtc_index(crtc)].state; 287 } 288 289 /** 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 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 */ 297 static inline struct drm_crtc_state * 298 drm_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 */ 311 static inline struct drm_crtc_state * 312 drm_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 /** 319 * 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. 325 * 326 * This function is deprecated, @drm_atomic_get_old_plane_state or 327 * @drm_atomic_get_new_plane_state should be used instead. 328 */ 329 static inline struct drm_plane_state * 330 drm_atomic_get_existing_plane_state(struct drm_atomic_state *state, 331 struct drm_plane *plane) 332 { 333 return state->planes[drm_plane_index(plane)].state; 334 } 335 336 /** 337 * 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 */ 344 static inline struct drm_plane_state * 345 drm_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 */ 359 static inline struct drm_plane_state * 360 drm_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 /** 367 * 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. 373 * 374 * This function is deprecated, @drm_atomic_get_old_connector_state or 375 * @drm_atomic_get_new_connector_state should be used instead. 376 */ 377 static inline struct drm_connector_state * 378 drm_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 386 return state->connectors[index].state; 387 } 388 389 /** 390 * 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 */ 397 static inline struct drm_connector_state * 398 drm_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 */ 417 static inline struct drm_connector_state * 418 drm_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 /** 430 * __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 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. 450 * 451 * Returns: 452 * 453 * Read-only pointer to the current plane state. 454 */ 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) 458 { 459 if (state->planes[drm_plane_index(plane)].state) 460 return state->planes[drm_plane_index(plane)].state; 461 462 return plane->state; 463 } 464 465 int __must_check 466 drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state, 467 struct drm_display_mode *mode); 468 int __must_check 469 drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state, 470 struct drm_property_blob *blob); 471 int __must_check 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); 478 int __must_check 479 drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state, 480 struct drm_crtc *crtc); 481 int __must_check 482 drm_atomic_add_affected_connectors(struct drm_atomic_state *state, 483 struct drm_crtc *crtc); 484 int __must_check 485 drm_atomic_add_affected_planes(struct drm_atomic_state *state, 486 struct drm_crtc *crtc); 487 488 void drm_atomic_legacy_backoff(struct drm_atomic_state *state); 489 490 void 491 drm_atomic_clean_old_fb(struct drm_device *dev, unsigned plane_mask, int ret); 492 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); 496 497 void drm_state_dump(struct drm_device *dev, struct drm_printer *p); 498 499 /** 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 */ 516 #define for_each_connector_in_state(__state, connector, connector_state, __i) \ 517 for ((__i) = 0; \ 518 (__i) < (__state)->num_connector && \ 519 ((connector) = (__state)->connectors[__i].ptr, \ 520 (connector_state) = (__state)->connectors[__i].state, 1); \ 521 (__i)++) \ 522 for_each_if (connector) 523 524 /** 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 */ 538 #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 547 /** 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 */ 559 #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 567 /** 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 */ 579 #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 587 /** 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 */ 604 #define for_each_crtc_in_state(__state, crtc, crtc_state, __i) \ 605 for ((__i) = 0; \ 606 (__i) < (__state)->dev->mode_config.num_crtc && \ 607 ((crtc) = (__state)->crtcs[__i].ptr, \ 608 (crtc_state) = (__state)->crtcs[__i].state, 1); \ 609 (__i)++) \ 610 for_each_if (crtc_state) 611 612 /** 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 */ 624 #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 633 /** 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 */ 644 #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 652 /** 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 */ 663 #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 671 /** 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 */ 688 #define for_each_plane_in_state(__state, plane, plane_state, __i) \ 689 for ((__i) = 0; \ 690 (__i) < (__state)->dev->mode_config.num_total_plane && \ 691 ((plane) = (__state)->planes[__i].ptr, \ 692 (plane_state) = (__state)->planes[__i].state, 1); \ 693 (__i)++) \ 694 for_each_if (plane_state) 695 696 /** 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 */ 708 #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 717 /** 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 */ 728 #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 736 /** 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 */ 747 #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 755 /** 756 * drm_atomic_crtc_needs_modeset - compute combined modeset need 757 * @state: &drm_crtc_state for the CRTC 758 * 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. 763 * 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 771 * should clear mode_changed in its &drm_mode_config_funcs.atomic_check 772 * implementation. 773 */ 774 static inline bool 775 drm_atomic_crtc_needs_modeset(const struct drm_crtc_state *state) 776 { 777 return state->mode_changed || state->active_changed || 778 state->connectors_changed; 779 } 780 781 #endif /* DRM_ATOMIC_H_ */ 782