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 #include <drm/drm_util.h> 33 34 /** 35 * struct drm_crtc_commit - track modeset commits on a CRTC 36 * 37 * This structure is used to track pending modeset changes and atomic commit on 38 * a per-CRTC basis. Since updating the list should never block this structure 39 * is reference counted to allow waiters to safely wait on an event to complete, 40 * without holding any locks. 41 * 42 * It has 3 different events in total to allow a fine-grained synchronization 43 * between outstanding updates:: 44 * 45 * atomic commit thread hardware 46 * 47 * write new state into hardware ----> ... 48 * signal hw_done 49 * switch to new state on next 50 * ... v/hblank 51 * 52 * wait for buffers to show up ... 53 * 54 * ... send completion irq 55 * irq handler signals flip_done 56 * cleanup old buffers 57 * 58 * signal cleanup_done 59 * 60 * wait for flip_done <---- 61 * clean up atomic state 62 * 63 * The important bit to know is that cleanup_done is the terminal event, but the 64 * ordering between flip_done and hw_done is entirely up to the specific driver 65 * and modeset state change. 66 * 67 * For an implementation of how to use this look at 68 * drm_atomic_helper_setup_commit() from the atomic helper library. 69 */ 70 struct drm_crtc_commit { 71 /** 72 * @crtc: 73 * 74 * DRM CRTC for this commit. 75 */ 76 struct drm_crtc *crtc; 77 78 /** 79 * @ref: 80 * 81 * Reference count for this structure. Needed to allow blocking on 82 * completions without the risk of the completion disappearing 83 * meanwhile. 84 */ 85 struct kref ref; 86 87 /** 88 * @flip_done: 89 * 90 * Will be signaled when the hardware has flipped to the new set of 91 * buffers. Signals at the same time as when the drm event for this 92 * commit is sent to userspace, or when an out-fence is singalled. Note 93 * that for most hardware, in most cases this happens after @hw_done is 94 * signalled. 95 */ 96 struct completion flip_done; 97 98 /** 99 * @hw_done: 100 * 101 * Will be signalled when all hw register changes for this commit have 102 * been written out. Especially when disabling a pipe this can be much 103 * later than than @flip_done, since that can signal already when the 104 * screen goes black, whereas to fully shut down a pipe more register 105 * I/O is required. 106 * 107 * Note that this does not need to include separately reference-counted 108 * resources like backing storage buffer pinning, or runtime pm 109 * management. 110 */ 111 struct completion hw_done; 112 113 /** 114 * @cleanup_done: 115 * 116 * Will be signalled after old buffers have been cleaned up by calling 117 * drm_atomic_helper_cleanup_planes(). Since this can only happen after 118 * a vblank wait completed it might be a bit later. This completion is 119 * useful to throttle updates and avoid hardware updates getting ahead 120 * of the buffer cleanup too much. 121 */ 122 struct completion cleanup_done; 123 124 /** 125 * @commit_entry: 126 * 127 * Entry on the per-CRTC &drm_crtc.commit_list. Protected by 128 * $drm_crtc.commit_lock. 129 */ 130 struct list_head commit_entry; 131 132 /** 133 * @event: 134 * 135 * &drm_pending_vblank_event pointer to clean up private events. 136 */ 137 struct drm_pending_vblank_event *event; 138 139 /** 140 * @abort_completion: 141 * 142 * A flag that's set after drm_atomic_helper_setup_commit takes a second 143 * reference for the completion of $drm_crtc_state.event. It's used by 144 * the free code to remove the second reference if commit fails. 145 */ 146 bool abort_completion; 147 }; 148 149 struct __drm_planes_state { 150 struct drm_plane *ptr; 151 struct drm_plane_state *state, *old_state, *new_state; 152 }; 153 154 struct __drm_crtcs_state { 155 struct drm_crtc *ptr; 156 struct drm_crtc_state *state, *old_state, *new_state; 157 158 /** 159 * @commit: 160 * 161 * A reference to the CRTC commit object that is kept for use by 162 * drm_atomic_helper_wait_for_flip_done() after 163 * drm_atomic_helper_commit_hw_done() is called. This ensures that a 164 * concurrent commit won't free a commit object that is still in use. 165 */ 166 struct drm_crtc_commit *commit; 167 168 s32 __user *out_fence_ptr; 169 u64 last_vblank_count; 170 }; 171 172 struct __drm_connnectors_state { 173 struct drm_connector *ptr; 174 struct drm_connector_state *state, *old_state, *new_state; 175 /** 176 * @out_fence_ptr: 177 * 178 * User-provided pointer which the kernel uses to return a sync_file 179 * file descriptor. Used by writeback connectors to signal completion of 180 * the writeback. 181 */ 182 s32 __user *out_fence_ptr; 183 }; 184 185 struct drm_private_obj; 186 struct drm_private_state; 187 188 /** 189 * struct drm_private_state_funcs - atomic state functions for private objects 190 * 191 * These hooks are used by atomic helpers to create, swap and destroy states of 192 * private objects. The structure itself is used as a vtable to identify the 193 * associated private object type. Each private object type that needs to be 194 * added to the atomic states is expected to have an implementation of these 195 * hooks and pass a pointer to it's drm_private_state_funcs struct to 196 * drm_atomic_get_private_obj_state(). 197 */ 198 struct drm_private_state_funcs { 199 /** 200 * @atomic_duplicate_state: 201 * 202 * Duplicate the current state of the private object and return it. It 203 * is an error to call this before obj->state has been initialized. 204 * 205 * RETURNS: 206 * 207 * Duplicated atomic state or NULL when obj->state is not 208 * initialized or allocation failed. 209 */ 210 struct drm_private_state *(*atomic_duplicate_state)(struct drm_private_obj *obj); 211 212 /** 213 * @atomic_destroy_state: 214 * 215 * Frees the private object state created with @atomic_duplicate_state. 216 */ 217 void (*atomic_destroy_state)(struct drm_private_obj *obj, 218 struct drm_private_state *state); 219 }; 220 221 /** 222 * struct drm_private_obj - base struct for driver private atomic object 223 * 224 * A driver private object is initialized by calling 225 * drm_atomic_private_obj_init() and cleaned up by calling 226 * drm_atomic_private_obj_fini(). 227 * 228 * Currently only tracks the state update functions and the opaque driver 229 * private state itself, but in the future might also track which 230 * &drm_modeset_lock is required to duplicate and update this object's state. 231 */ 232 struct drm_private_obj { 233 /** 234 * @state: Current atomic state for this driver private object. 235 */ 236 struct drm_private_state *state; 237 238 /** 239 * @funcs: 240 * 241 * Functions to manipulate the state of this driver private object, see 242 * &drm_private_state_funcs. 243 */ 244 const struct drm_private_state_funcs *funcs; 245 }; 246 247 /** 248 * struct drm_private_state - base struct for driver private object state 249 * @state: backpointer to global drm_atomic_state 250 * 251 * Currently only contains a backpointer to the overall atomic update, but in 252 * the future also might hold synchronization information similar to e.g. 253 * &drm_crtc.commit. 254 */ 255 struct drm_private_state { 256 struct drm_atomic_state *state; 257 }; 258 259 struct __drm_private_objs_state { 260 struct drm_private_obj *ptr; 261 struct drm_private_state *state, *old_state, *new_state; 262 }; 263 264 /** 265 * struct drm_atomic_state - the global state object for atomic updates 266 * @ref: count of all references to this state (will not be freed until zero) 267 * @dev: parent DRM device 268 * @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics 269 * @async_update: hint for asynchronous plane update 270 * @planes: pointer to array of structures with per-plane data 271 * @crtcs: pointer to array of CRTC pointers 272 * @num_connector: size of the @connectors and @connector_states arrays 273 * @connectors: pointer to array of structures with per-connector data 274 * @num_private_objs: size of the @private_objs array 275 * @private_objs: pointer to array of private object pointers 276 * @acquire_ctx: acquire context for this atomic modeset state update 277 * 278 * States are added to an atomic update by calling drm_atomic_get_crtc_state(), 279 * drm_atomic_get_plane_state(), drm_atomic_get_connector_state(), or for 280 * private state structures, drm_atomic_get_private_obj_state(). 281 */ 282 struct drm_atomic_state { 283 struct kref ref; 284 285 struct drm_device *dev; 286 287 /** 288 * @allow_modeset: 289 * 290 * Allow full modeset. This is used by the ATOMIC IOCTL handler to 291 * implement the DRM_MODE_ATOMIC_ALLOW_MODESET flag. Drivers should 292 * never consult this flag, instead looking at the output of 293 * drm_atomic_crtc_needs_modeset(). 294 */ 295 bool allow_modeset : 1; 296 bool legacy_cursor_update : 1; 297 bool async_update : 1; 298 struct __drm_planes_state *planes; 299 struct __drm_crtcs_state *crtcs; 300 int num_connector; 301 struct __drm_connnectors_state *connectors; 302 int num_private_objs; 303 struct __drm_private_objs_state *private_objs; 304 305 struct drm_modeset_acquire_ctx *acquire_ctx; 306 307 /** 308 * @fake_commit: 309 * 310 * Used for signaling unbound planes/connectors. 311 * When a connector or plane is not bound to any CRTC, it's still important 312 * to preserve linearity to prevent the atomic states from being freed to early. 313 * 314 * This commit (if set) is not bound to any crtc, but will be completed when 315 * drm_atomic_helper_commit_hw_done() is called. 316 */ 317 struct drm_crtc_commit *fake_commit; 318 319 /** 320 * @commit_work: 321 * 322 * Work item which can be used by the driver or helpers to execute the 323 * commit without blocking. 324 */ 325 struct work_struct commit_work; 326 }; 327 328 void __drm_crtc_commit_free(struct kref *kref); 329 330 /** 331 * drm_crtc_commit_get - acquire a reference to the CRTC commit 332 * @commit: CRTC commit 333 * 334 * Increases the reference of @commit. 335 * 336 * Returns: 337 * The pointer to @commit, with reference increased. 338 */ 339 static inline struct drm_crtc_commit *drm_crtc_commit_get(struct drm_crtc_commit *commit) 340 { 341 kref_get(&commit->ref); 342 return commit; 343 } 344 345 /** 346 * drm_crtc_commit_put - release a reference to the CRTC commmit 347 * @commit: CRTC commit 348 * 349 * This releases a reference to @commit which is freed after removing the 350 * final reference. No locking required and callable from any context. 351 */ 352 static inline void drm_crtc_commit_put(struct drm_crtc_commit *commit) 353 { 354 kref_put(&commit->ref, __drm_crtc_commit_free); 355 } 356 357 struct drm_atomic_state * __must_check 358 drm_atomic_state_alloc(struct drm_device *dev); 359 void drm_atomic_state_clear(struct drm_atomic_state *state); 360 361 /** 362 * drm_atomic_state_get - acquire a reference to the atomic state 363 * @state: The atomic state 364 * 365 * Returns a new reference to the @state 366 */ 367 static inline struct drm_atomic_state * 368 drm_atomic_state_get(struct drm_atomic_state *state) 369 { 370 kref_get(&state->ref); 371 return state; 372 } 373 374 void __drm_atomic_state_free(struct kref *ref); 375 376 /** 377 * drm_atomic_state_put - release a reference to the atomic state 378 * @state: The atomic state 379 * 380 * This releases a reference to @state which is freed after removing the 381 * final reference. No locking required and callable from any context. 382 */ 383 static inline void drm_atomic_state_put(struct drm_atomic_state *state) 384 { 385 kref_put(&state->ref, __drm_atomic_state_free); 386 } 387 388 int __must_check 389 drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state); 390 void drm_atomic_state_default_clear(struct drm_atomic_state *state); 391 void drm_atomic_state_default_release(struct drm_atomic_state *state); 392 393 struct drm_crtc_state * __must_check 394 drm_atomic_get_crtc_state(struct drm_atomic_state *state, 395 struct drm_crtc *crtc); 396 struct drm_plane_state * __must_check 397 drm_atomic_get_plane_state(struct drm_atomic_state *state, 398 struct drm_plane *plane); 399 struct drm_connector_state * __must_check 400 drm_atomic_get_connector_state(struct drm_atomic_state *state, 401 struct drm_connector *connector); 402 403 void drm_atomic_private_obj_init(struct drm_private_obj *obj, 404 struct drm_private_state *state, 405 const struct drm_private_state_funcs *funcs); 406 void drm_atomic_private_obj_fini(struct drm_private_obj *obj); 407 408 struct drm_private_state * __must_check 409 drm_atomic_get_private_obj_state(struct drm_atomic_state *state, 410 struct drm_private_obj *obj); 411 412 /** 413 * drm_atomic_get_existing_crtc_state - get crtc state, if it exists 414 * @state: global atomic state object 415 * @crtc: crtc to grab 416 * 417 * This function returns the crtc state for the given crtc, or NULL 418 * if the crtc is not part of the global atomic state. 419 * 420 * This function is deprecated, @drm_atomic_get_old_crtc_state or 421 * @drm_atomic_get_new_crtc_state should be used instead. 422 */ 423 static inline struct drm_crtc_state * 424 drm_atomic_get_existing_crtc_state(struct drm_atomic_state *state, 425 struct drm_crtc *crtc) 426 { 427 return state->crtcs[drm_crtc_index(crtc)].state; 428 } 429 430 /** 431 * drm_atomic_get_old_crtc_state - get old crtc state, if it exists 432 * @state: global atomic state object 433 * @crtc: crtc to grab 434 * 435 * This function returns the old crtc state for the given crtc, or 436 * NULL if the crtc is not part of the global atomic state. 437 */ 438 static inline struct drm_crtc_state * 439 drm_atomic_get_old_crtc_state(struct drm_atomic_state *state, 440 struct drm_crtc *crtc) 441 { 442 return state->crtcs[drm_crtc_index(crtc)].old_state; 443 } 444 /** 445 * drm_atomic_get_new_crtc_state - get new crtc state, if it exists 446 * @state: global atomic state object 447 * @crtc: crtc to grab 448 * 449 * This function returns the new crtc state for the given crtc, or 450 * NULL if the crtc is not part of the global atomic state. 451 */ 452 static inline struct drm_crtc_state * 453 drm_atomic_get_new_crtc_state(struct drm_atomic_state *state, 454 struct drm_crtc *crtc) 455 { 456 return state->crtcs[drm_crtc_index(crtc)].new_state; 457 } 458 459 /** 460 * drm_atomic_get_existing_plane_state - get plane state, if it exists 461 * @state: global atomic state object 462 * @plane: plane to grab 463 * 464 * This function returns the plane state for the given plane, or NULL 465 * if the plane is not part of the global atomic state. 466 * 467 * This function is deprecated, @drm_atomic_get_old_plane_state or 468 * @drm_atomic_get_new_plane_state should be used instead. 469 */ 470 static inline struct drm_plane_state * 471 drm_atomic_get_existing_plane_state(struct drm_atomic_state *state, 472 struct drm_plane *plane) 473 { 474 return state->planes[drm_plane_index(plane)].state; 475 } 476 477 /** 478 * drm_atomic_get_old_plane_state - get plane state, if it exists 479 * @state: global atomic state object 480 * @plane: plane to grab 481 * 482 * This function returns the old plane state for the given plane, or 483 * NULL if the plane is not part of the global atomic state. 484 */ 485 static inline struct drm_plane_state * 486 drm_atomic_get_old_plane_state(struct drm_atomic_state *state, 487 struct drm_plane *plane) 488 { 489 return state->planes[drm_plane_index(plane)].old_state; 490 } 491 492 /** 493 * drm_atomic_get_new_plane_state - get plane state, if it exists 494 * @state: global atomic state object 495 * @plane: plane to grab 496 * 497 * This function returns the new plane state for the given plane, or 498 * NULL if the plane is not part of the global atomic state. 499 */ 500 static inline struct drm_plane_state * 501 drm_atomic_get_new_plane_state(struct drm_atomic_state *state, 502 struct drm_plane *plane) 503 { 504 return state->planes[drm_plane_index(plane)].new_state; 505 } 506 507 /** 508 * drm_atomic_get_existing_connector_state - get connector state, if it exists 509 * @state: global atomic state object 510 * @connector: connector to grab 511 * 512 * This function returns the connector state for the given connector, 513 * or NULL if the connector is not part of the global atomic state. 514 * 515 * This function is deprecated, @drm_atomic_get_old_connector_state or 516 * @drm_atomic_get_new_connector_state should be used instead. 517 */ 518 static inline struct drm_connector_state * 519 drm_atomic_get_existing_connector_state(struct drm_atomic_state *state, 520 struct drm_connector *connector) 521 { 522 int index = drm_connector_index(connector); 523 524 if (index >= state->num_connector) 525 return NULL; 526 527 return state->connectors[index].state; 528 } 529 530 /** 531 * drm_atomic_get_old_connector_state - get connector state, if it exists 532 * @state: global atomic state object 533 * @connector: connector to grab 534 * 535 * This function returns the old connector state for the given connector, 536 * or NULL if the connector is not part of the global atomic state. 537 */ 538 static inline struct drm_connector_state * 539 drm_atomic_get_old_connector_state(struct drm_atomic_state *state, 540 struct drm_connector *connector) 541 { 542 int index = drm_connector_index(connector); 543 544 if (index >= state->num_connector) 545 return NULL; 546 547 return state->connectors[index].old_state; 548 } 549 550 /** 551 * drm_atomic_get_new_connector_state - get connector state, if it exists 552 * @state: global atomic state object 553 * @connector: connector to grab 554 * 555 * This function returns the new connector state for the given connector, 556 * or NULL if the connector is not part of the global atomic state. 557 */ 558 static inline struct drm_connector_state * 559 drm_atomic_get_new_connector_state(struct drm_atomic_state *state, 560 struct drm_connector *connector) 561 { 562 int index = drm_connector_index(connector); 563 564 if (index >= state->num_connector) 565 return NULL; 566 567 return state->connectors[index].new_state; 568 } 569 570 /** 571 * __drm_atomic_get_current_plane_state - get current plane state 572 * @state: global atomic state object 573 * @plane: plane to grab 574 * 575 * This function returns the plane state for the given plane, either from 576 * @state, or if the plane isn't part of the atomic state update, from @plane. 577 * This is useful in atomic check callbacks, when drivers need to peek at, but 578 * not change, state of other planes, since it avoids threading an error code 579 * back up the call chain. 580 * 581 * WARNING: 582 * 583 * Note that this function is in general unsafe since it doesn't check for the 584 * required locking for access state structures. Drivers must ensure that it is 585 * safe to access the returned state structure through other means. One common 586 * example is when planes are fixed to a single CRTC, and the driver knows that 587 * the CRTC lock is held already. In that case holding the CRTC lock gives a 588 * read-lock on all planes connected to that CRTC. But if planes can be 589 * reassigned things get more tricky. In that case it's better to use 590 * drm_atomic_get_plane_state and wire up full error handling. 591 * 592 * Returns: 593 * 594 * Read-only pointer to the current plane state. 595 */ 596 static inline const struct drm_plane_state * 597 __drm_atomic_get_current_plane_state(struct drm_atomic_state *state, 598 struct drm_plane *plane) 599 { 600 if (state->planes[drm_plane_index(plane)].state) 601 return state->planes[drm_plane_index(plane)].state; 602 603 return plane->state; 604 } 605 606 int __must_check 607 drm_atomic_add_affected_connectors(struct drm_atomic_state *state, 608 struct drm_crtc *crtc); 609 int __must_check 610 drm_atomic_add_affected_planes(struct drm_atomic_state *state, 611 struct drm_crtc *crtc); 612 613 int __must_check drm_atomic_check_only(struct drm_atomic_state *state); 614 int __must_check drm_atomic_commit(struct drm_atomic_state *state); 615 int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_state *state); 616 617 void drm_state_dump(struct drm_device *dev, struct drm_printer *p); 618 619 /** 620 * for_each_oldnew_connector_in_state - iterate over all connectors in an atomic update 621 * @__state: &struct drm_atomic_state pointer 622 * @connector: &struct drm_connector iteration cursor 623 * @old_connector_state: &struct drm_connector_state iteration cursor for the 624 * old state 625 * @new_connector_state: &struct drm_connector_state iteration cursor for the 626 * new state 627 * @__i: int iteration cursor, for macro-internal use 628 * 629 * This iterates over all connectors in an atomic update, tracking both old and 630 * new state. This is useful in places where the state delta needs to be 631 * considered, for example in atomic check functions. 632 */ 633 #define for_each_oldnew_connector_in_state(__state, connector, old_connector_state, new_connector_state, __i) \ 634 for ((__i) = 0; \ 635 (__i) < (__state)->num_connector; \ 636 (__i)++) \ 637 for_each_if ((__state)->connectors[__i].ptr && \ 638 ((connector) = (__state)->connectors[__i].ptr, \ 639 (old_connector_state) = (__state)->connectors[__i].old_state, \ 640 (new_connector_state) = (__state)->connectors[__i].new_state, 1)) 641 642 /** 643 * for_each_old_connector_in_state - iterate over all connectors in an atomic update 644 * @__state: &struct drm_atomic_state pointer 645 * @connector: &struct drm_connector iteration cursor 646 * @old_connector_state: &struct drm_connector_state iteration cursor for the 647 * old state 648 * @__i: int iteration cursor, for macro-internal use 649 * 650 * This iterates over all connectors in an atomic update, tracking only the old 651 * state. This is useful in disable functions, where we need the old state the 652 * hardware is still in. 653 */ 654 #define for_each_old_connector_in_state(__state, connector, old_connector_state, __i) \ 655 for ((__i) = 0; \ 656 (__i) < (__state)->num_connector; \ 657 (__i)++) \ 658 for_each_if ((__state)->connectors[__i].ptr && \ 659 ((connector) = (__state)->connectors[__i].ptr, \ 660 (old_connector_state) = (__state)->connectors[__i].old_state, 1)) 661 662 /** 663 * for_each_new_connector_in_state - iterate over all connectors in an atomic update 664 * @__state: &struct drm_atomic_state pointer 665 * @connector: &struct drm_connector iteration cursor 666 * @new_connector_state: &struct drm_connector_state iteration cursor for the 667 * new state 668 * @__i: int iteration cursor, for macro-internal use 669 * 670 * This iterates over all connectors in an atomic update, tracking only the new 671 * state. This is useful in enable functions, where we need the new state the 672 * hardware should be in when the atomic commit operation has completed. 673 */ 674 #define for_each_new_connector_in_state(__state, connector, new_connector_state, __i) \ 675 for ((__i) = 0; \ 676 (__i) < (__state)->num_connector; \ 677 (__i)++) \ 678 for_each_if ((__state)->connectors[__i].ptr && \ 679 ((connector) = (__state)->connectors[__i].ptr, \ 680 (new_connector_state) = (__state)->connectors[__i].new_state, 1)) 681 682 /** 683 * for_each_oldnew_crtc_in_state - iterate over all CRTCs in an atomic update 684 * @__state: &struct drm_atomic_state pointer 685 * @crtc: &struct drm_crtc iteration cursor 686 * @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state 687 * @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state 688 * @__i: int iteration cursor, for macro-internal use 689 * 690 * This iterates over all CRTCs in an atomic update, tracking both old and 691 * new state. This is useful in places where the state delta needs to be 692 * considered, for example in atomic check functions. 693 */ 694 #define for_each_oldnew_crtc_in_state(__state, crtc, old_crtc_state, new_crtc_state, __i) \ 695 for ((__i) = 0; \ 696 (__i) < (__state)->dev->mode_config.num_crtc; \ 697 (__i)++) \ 698 for_each_if ((__state)->crtcs[__i].ptr && \ 699 ((crtc) = (__state)->crtcs[__i].ptr, \ 700 (old_crtc_state) = (__state)->crtcs[__i].old_state, \ 701 (new_crtc_state) = (__state)->crtcs[__i].new_state, 1)) 702 703 /** 704 * for_each_old_crtc_in_state - iterate over all CRTCs in an atomic update 705 * @__state: &struct drm_atomic_state pointer 706 * @crtc: &struct drm_crtc iteration cursor 707 * @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state 708 * @__i: int iteration cursor, for macro-internal use 709 * 710 * This iterates over all CRTCs in an atomic update, tracking only the old 711 * state. This is useful in disable functions, where we need the old state the 712 * hardware is still in. 713 */ 714 #define for_each_old_crtc_in_state(__state, crtc, old_crtc_state, __i) \ 715 for ((__i) = 0; \ 716 (__i) < (__state)->dev->mode_config.num_crtc; \ 717 (__i)++) \ 718 for_each_if ((__state)->crtcs[__i].ptr && \ 719 ((crtc) = (__state)->crtcs[__i].ptr, \ 720 (old_crtc_state) = (__state)->crtcs[__i].old_state, 1)) 721 722 /** 723 * for_each_new_crtc_in_state - iterate over all CRTCs in an atomic update 724 * @__state: &struct drm_atomic_state pointer 725 * @crtc: &struct drm_crtc iteration cursor 726 * @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state 727 * @__i: int iteration cursor, for macro-internal use 728 * 729 * This iterates over all CRTCs in an atomic update, tracking only the new 730 * state. This is useful in enable functions, where we need the new state the 731 * hardware should be in when the atomic commit operation has completed. 732 */ 733 #define for_each_new_crtc_in_state(__state, crtc, new_crtc_state, __i) \ 734 for ((__i) = 0; \ 735 (__i) < (__state)->dev->mode_config.num_crtc; \ 736 (__i)++) \ 737 for_each_if ((__state)->crtcs[__i].ptr && \ 738 ((crtc) = (__state)->crtcs[__i].ptr, \ 739 (new_crtc_state) = (__state)->crtcs[__i].new_state, 1)) 740 741 /** 742 * for_each_oldnew_plane_in_state - iterate over all planes in an atomic update 743 * @__state: &struct drm_atomic_state pointer 744 * @plane: &struct drm_plane iteration cursor 745 * @old_plane_state: &struct drm_plane_state iteration cursor for the old state 746 * @new_plane_state: &struct drm_plane_state iteration cursor for the new state 747 * @__i: int iteration cursor, for macro-internal use 748 * 749 * This iterates over all planes in an atomic update, tracking both old and 750 * new state. This is useful in places where the state delta needs to be 751 * considered, for example in atomic check functions. 752 */ 753 #define for_each_oldnew_plane_in_state(__state, plane, old_plane_state, new_plane_state, __i) \ 754 for ((__i) = 0; \ 755 (__i) < (__state)->dev->mode_config.num_total_plane; \ 756 (__i)++) \ 757 for_each_if ((__state)->planes[__i].ptr && \ 758 ((plane) = (__state)->planes[__i].ptr, \ 759 (old_plane_state) = (__state)->planes[__i].old_state,\ 760 (new_plane_state) = (__state)->planes[__i].new_state, 1)) 761 762 /** 763 * for_each_oldnew_plane_in_state_reverse - iterate over all planes in an atomic 764 * update in reverse order 765 * @__state: &struct drm_atomic_state pointer 766 * @plane: &struct drm_plane iteration cursor 767 * @old_plane_state: &struct drm_plane_state iteration cursor for the old state 768 * @new_plane_state: &struct drm_plane_state iteration cursor for the new state 769 * @__i: int iteration cursor, for macro-internal use 770 * 771 * This iterates over all planes in an atomic update in reverse order, 772 * tracking both old and new state. This is useful in places where the 773 * state delta needs to be considered, for example in atomic check functions. 774 */ 775 #define for_each_oldnew_plane_in_state_reverse(__state, plane, old_plane_state, new_plane_state, __i) \ 776 for ((__i) = ((__state)->dev->mode_config.num_total_plane - 1); \ 777 (__i) >= 0; \ 778 (__i)--) \ 779 for_each_if ((__state)->planes[__i].ptr && \ 780 ((plane) = (__state)->planes[__i].ptr, \ 781 (old_plane_state) = (__state)->planes[__i].old_state,\ 782 (new_plane_state) = (__state)->planes[__i].new_state, 1)) 783 784 /** 785 * for_each_old_plane_in_state - iterate over all planes in an atomic update 786 * @__state: &struct drm_atomic_state pointer 787 * @plane: &struct drm_plane iteration cursor 788 * @old_plane_state: &struct drm_plane_state iteration cursor for the old state 789 * @__i: int iteration cursor, for macro-internal use 790 * 791 * This iterates over all planes in an atomic update, tracking only the old 792 * state. This is useful in disable functions, where we need the old state the 793 * hardware is still in. 794 */ 795 #define for_each_old_plane_in_state(__state, plane, old_plane_state, __i) \ 796 for ((__i) = 0; \ 797 (__i) < (__state)->dev->mode_config.num_total_plane; \ 798 (__i)++) \ 799 for_each_if ((__state)->planes[__i].ptr && \ 800 ((plane) = (__state)->planes[__i].ptr, \ 801 (old_plane_state) = (__state)->planes[__i].old_state, 1)) 802 /** 803 * for_each_new_plane_in_state - iterate over all planes in an atomic update 804 * @__state: &struct drm_atomic_state pointer 805 * @plane: &struct drm_plane iteration cursor 806 * @new_plane_state: &struct drm_plane_state iteration cursor for the new state 807 * @__i: int iteration cursor, for macro-internal use 808 * 809 * This iterates over all planes in an atomic update, tracking only the new 810 * state. This is useful in enable functions, where we need the new state the 811 * hardware should be in when the atomic commit operation has completed. 812 */ 813 #define for_each_new_plane_in_state(__state, plane, new_plane_state, __i) \ 814 for ((__i) = 0; \ 815 (__i) < (__state)->dev->mode_config.num_total_plane; \ 816 (__i)++) \ 817 for_each_if ((__state)->planes[__i].ptr && \ 818 ((plane) = (__state)->planes[__i].ptr, \ 819 (new_plane_state) = (__state)->planes[__i].new_state, 1)) 820 821 /** 822 * for_each_oldnew_private_obj_in_state - iterate over all private objects in an atomic update 823 * @__state: &struct drm_atomic_state pointer 824 * @obj: &struct drm_private_obj iteration cursor 825 * @old_obj_state: &struct drm_private_state iteration cursor for the old state 826 * @new_obj_state: &struct drm_private_state iteration cursor for the new state 827 * @__i: int iteration cursor, for macro-internal use 828 * 829 * This iterates over all private objects in an atomic update, tracking both 830 * old and new state. This is useful in places where the state delta needs 831 * to be considered, for example in atomic check functions. 832 */ 833 #define for_each_oldnew_private_obj_in_state(__state, obj, old_obj_state, new_obj_state, __i) \ 834 for ((__i) = 0; \ 835 (__i) < (__state)->num_private_objs && \ 836 ((obj) = (__state)->private_objs[__i].ptr, \ 837 (old_obj_state) = (__state)->private_objs[__i].old_state, \ 838 (new_obj_state) = (__state)->private_objs[__i].new_state, 1); \ 839 (__i)++) 840 841 /** 842 * for_each_old_private_obj_in_state - iterate over all private objects in an atomic update 843 * @__state: &struct drm_atomic_state pointer 844 * @obj: &struct drm_private_obj iteration cursor 845 * @old_obj_state: &struct drm_private_state iteration cursor for the old state 846 * @__i: int iteration cursor, for macro-internal use 847 * 848 * This iterates over all private objects in an atomic update, tracking only 849 * the old state. This is useful in disable functions, where we need the old 850 * state the hardware is still in. 851 */ 852 #define for_each_old_private_obj_in_state(__state, obj, old_obj_state, __i) \ 853 for ((__i) = 0; \ 854 (__i) < (__state)->num_private_objs && \ 855 ((obj) = (__state)->private_objs[__i].ptr, \ 856 (old_obj_state) = (__state)->private_objs[__i].old_state, 1); \ 857 (__i)++) 858 859 /** 860 * for_each_new_private_obj_in_state - iterate over all private objects in an atomic update 861 * @__state: &struct drm_atomic_state pointer 862 * @obj: &struct drm_private_obj iteration cursor 863 * @new_obj_state: &struct drm_private_state iteration cursor for the new state 864 * @__i: int iteration cursor, for macro-internal use 865 * 866 * This iterates over all private objects in an atomic update, tracking only 867 * the new state. This is useful in enable functions, where we need the new state the 868 * hardware should be in when the atomic commit operation has completed. 869 */ 870 #define for_each_new_private_obj_in_state(__state, obj, new_obj_state, __i) \ 871 for ((__i) = 0; \ 872 (__i) < (__state)->num_private_objs && \ 873 ((obj) = (__state)->private_objs[__i].ptr, \ 874 (new_obj_state) = (__state)->private_objs[__i].new_state, 1); \ 875 (__i)++) 876 877 /** 878 * drm_atomic_crtc_needs_modeset - compute combined modeset need 879 * @state: &drm_crtc_state for the CRTC 880 * 881 * To give drivers flexibility &struct drm_crtc_state has 3 booleans to track 882 * whether the state CRTC changed enough to need a full modeset cycle: 883 * mode_changed, active_changed and connectors_changed. This helper simply 884 * combines these three to compute the overall need for a modeset for @state. 885 * 886 * The atomic helper code sets these booleans, but drivers can and should 887 * change them appropriately to accurately represent whether a modeset is 888 * really needed. In general, drivers should avoid full modesets whenever 889 * possible. 890 * 891 * For example if the CRTC mode has changed, and the hardware is able to enact 892 * the requested mode change without going through a full modeset, the driver 893 * should clear mode_changed in its &drm_mode_config_funcs.atomic_check 894 * implementation. 895 */ 896 static inline bool 897 drm_atomic_crtc_needs_modeset(const struct drm_crtc_state *state) 898 { 899 return state->mode_changed || state->active_changed || 900 state->connectors_changed; 901 } 902 903 #endif /* DRM_ATOMIC_H_ */ 904