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 * Completion of this stage is signalled implicitly by calling 97 * drm_crtc_send_vblank_event() on &drm_crtc_state.event. 98 */ 99 struct completion flip_done; 100 101 /** 102 * @hw_done: 103 * 104 * Will be signalled when all hw register changes for this commit have 105 * been written out. Especially when disabling a pipe this can be much 106 * later than @flip_done, since that can signal already when the 107 * screen goes black, whereas to fully shut down a pipe more register 108 * I/O is required. 109 * 110 * Note that this does not need to include separately reference-counted 111 * resources like backing storage buffer pinning, or runtime pm 112 * management. 113 * 114 * Drivers should call drm_atomic_helper_commit_hw_done() to signal 115 * completion of this stage. 116 */ 117 struct completion hw_done; 118 119 /** 120 * @cleanup_done: 121 * 122 * Will be signalled after old buffers have been cleaned up by calling 123 * drm_atomic_helper_cleanup_planes(). Since this can only happen after 124 * a vblank wait completed it might be a bit later. This completion is 125 * useful to throttle updates and avoid hardware updates getting ahead 126 * of the buffer cleanup too much. 127 * 128 * Drivers should call drm_atomic_helper_commit_cleanup_done() to signal 129 * completion of this stage. 130 */ 131 struct completion cleanup_done; 132 133 /** 134 * @commit_entry: 135 * 136 * Entry on the per-CRTC &drm_crtc.commit_list. Protected by 137 * $drm_crtc.commit_lock. 138 */ 139 struct list_head commit_entry; 140 141 /** 142 * @event: 143 * 144 * &drm_pending_vblank_event pointer to clean up private events. 145 */ 146 struct drm_pending_vblank_event *event; 147 148 /** 149 * @abort_completion: 150 * 151 * A flag that's set after drm_atomic_helper_setup_commit() takes a 152 * second reference for the completion of $drm_crtc_state.event. It's 153 * used by the free code to remove the second reference if commit fails. 154 */ 155 bool abort_completion; 156 }; 157 158 struct __drm_planes_state { 159 struct drm_plane *ptr; 160 struct drm_plane_state *state, *old_state, *new_state; 161 }; 162 163 struct __drm_crtcs_state { 164 struct drm_crtc *ptr; 165 struct drm_crtc_state *state, *old_state, *new_state; 166 167 /** 168 * @commit: 169 * 170 * A reference to the CRTC commit object that is kept for use by 171 * drm_atomic_helper_wait_for_flip_done() after 172 * drm_atomic_helper_commit_hw_done() is called. This ensures that a 173 * concurrent commit won't free a commit object that is still in use. 174 */ 175 struct drm_crtc_commit *commit; 176 177 s32 __user *out_fence_ptr; 178 u64 last_vblank_count; 179 }; 180 181 struct __drm_connnectors_state { 182 struct drm_connector *ptr; 183 struct drm_connector_state *state, *old_state, *new_state; 184 /** 185 * @out_fence_ptr: 186 * 187 * User-provided pointer which the kernel uses to return a sync_file 188 * file descriptor. Used by writeback connectors to signal completion of 189 * the writeback. 190 */ 191 s32 __user *out_fence_ptr; 192 }; 193 194 struct drm_private_obj; 195 struct drm_private_state; 196 197 /** 198 * struct drm_private_state_funcs - atomic state functions for private objects 199 * 200 * These hooks are used by atomic helpers to create, swap and destroy states of 201 * private objects. The structure itself is used as a vtable to identify the 202 * associated private object type. Each private object type that needs to be 203 * added to the atomic states is expected to have an implementation of these 204 * hooks and pass a pointer to its drm_private_state_funcs struct to 205 * drm_atomic_get_private_obj_state(). 206 */ 207 struct drm_private_state_funcs { 208 /** 209 * @atomic_duplicate_state: 210 * 211 * Duplicate the current state of the private object and return it. It 212 * is an error to call this before obj->state has been initialized. 213 * 214 * RETURNS: 215 * 216 * Duplicated atomic state or NULL when obj->state is not 217 * initialized or allocation failed. 218 */ 219 struct drm_private_state *(*atomic_duplicate_state)(struct drm_private_obj *obj); 220 221 /** 222 * @atomic_destroy_state: 223 * 224 * Frees the private object state created with @atomic_duplicate_state. 225 */ 226 void (*atomic_destroy_state)(struct drm_private_obj *obj, 227 struct drm_private_state *state); 228 }; 229 230 /** 231 * struct drm_private_obj - base struct for driver private atomic object 232 * 233 * A driver private object is initialized by calling 234 * drm_atomic_private_obj_init() and cleaned up by calling 235 * drm_atomic_private_obj_fini(). 236 * 237 * Currently only tracks the state update functions and the opaque driver 238 * private state itself, but in the future might also track which 239 * &drm_modeset_lock is required to duplicate and update this object's state. 240 * 241 * All private objects must be initialized before the DRM device they are 242 * attached to is registered to the DRM subsystem (call to drm_dev_register()) 243 * and should stay around until this DRM device is unregistered (call to 244 * drm_dev_unregister()). In other words, private objects lifetime is tied 245 * to the DRM device lifetime. This implies that: 246 * 247 * 1/ all calls to drm_atomic_private_obj_init() must be done before calling 248 * drm_dev_register() 249 * 2/ all calls to drm_atomic_private_obj_fini() must be done after calling 250 * drm_dev_unregister() 251 * 252 * If that private object is used to store a state shared by multiple 253 * CRTCs, proper care must be taken to ensure that non-blocking commits are 254 * properly ordered to avoid a use-after-free issue. 255 * 256 * Indeed, assuming a sequence of two non-blocking &drm_atomic_commit on two 257 * different &drm_crtc using different &drm_plane and &drm_connector, so with no 258 * resources shared, there's no guarantee on which commit is going to happen 259 * first. However, the second &drm_atomic_commit will consider the first 260 * &drm_private_obj its old state, and will be in charge of freeing it whenever 261 * the second &drm_atomic_commit is done. 262 * 263 * If the first &drm_atomic_commit happens after it, it will consider its 264 * &drm_private_obj the new state and will be likely to access it, resulting in 265 * an access to a freed memory region. Drivers should store (and get a reference 266 * to) the &drm_crtc_commit structure in our private state in 267 * &drm_mode_config_helper_funcs.atomic_commit_setup, and then wait for that 268 * commit to complete as the first step of 269 * &drm_mode_config_helper_funcs.atomic_commit_tail, similar to 270 * drm_atomic_helper_wait_for_dependencies(). 271 */ 272 struct drm_private_obj { 273 /** 274 * @head: List entry used to attach a private object to a &drm_device 275 * (queued to &drm_mode_config.privobj_list). 276 */ 277 struct list_head head; 278 279 /** 280 * @lock: Modeset lock to protect the state object. 281 */ 282 struct drm_modeset_lock lock; 283 284 /** 285 * @state: Current atomic state for this driver private object. 286 */ 287 struct drm_private_state *state; 288 289 /** 290 * @funcs: 291 * 292 * Functions to manipulate the state of this driver private object, see 293 * &drm_private_state_funcs. 294 */ 295 const struct drm_private_state_funcs *funcs; 296 }; 297 298 /** 299 * drm_for_each_privobj() - private object iterator 300 * 301 * @privobj: pointer to the current private object. Updated after each 302 * iteration 303 * @dev: the DRM device we want get private objects from 304 * 305 * Allows one to iterate over all private objects attached to @dev 306 */ 307 #define drm_for_each_privobj(privobj, dev) \ 308 list_for_each_entry(privobj, &(dev)->mode_config.privobj_list, head) 309 310 /** 311 * struct drm_private_state - base struct for driver private object state 312 * @state: backpointer to global drm_atomic_state 313 * 314 * Currently only contains a backpointer to the overall atomic update, but in 315 * the future also might hold synchronization information similar to e.g. 316 * &drm_crtc.commit. 317 */ 318 struct drm_private_state { 319 struct drm_atomic_state *state; 320 }; 321 322 struct __drm_private_objs_state { 323 struct drm_private_obj *ptr; 324 struct drm_private_state *state, *old_state, *new_state; 325 }; 326 327 /** 328 * struct drm_atomic_state - the global state object for atomic updates 329 * @ref: count of all references to this state (will not be freed until zero) 330 * @dev: parent DRM device 331 * @async_update: hint for asynchronous plane update 332 * @planes: pointer to array of structures with per-plane data 333 * @crtcs: pointer to array of CRTC pointers 334 * @num_connector: size of the @connectors and @connector_states arrays 335 * @connectors: pointer to array of structures with per-connector data 336 * @num_private_objs: size of the @private_objs array 337 * @private_objs: pointer to array of private object pointers 338 * @acquire_ctx: acquire context for this atomic modeset state update 339 * 340 * States are added to an atomic update by calling drm_atomic_get_crtc_state(), 341 * drm_atomic_get_plane_state(), drm_atomic_get_connector_state(), or for 342 * private state structures, drm_atomic_get_private_obj_state(). 343 */ 344 struct drm_atomic_state { 345 struct kref ref; 346 347 struct drm_device *dev; 348 349 /** 350 * @allow_modeset: 351 * 352 * Allow full modeset. This is used by the ATOMIC IOCTL handler to 353 * implement the DRM_MODE_ATOMIC_ALLOW_MODESET flag. Drivers should 354 * never consult this flag, instead looking at the output of 355 * drm_atomic_crtc_needs_modeset(). 356 */ 357 bool allow_modeset : 1; 358 /** 359 * @legacy_cursor_update: 360 * 361 * Hint to enforce legacy cursor IOCTL semantics. 362 * 363 * WARNING: This is thoroughly broken and pretty much impossible to 364 * implement correctly. Drivers must ignore this and should instead 365 * implement &drm_plane_helper_funcs.atomic_async_check and 366 * &drm_plane_helper_funcs.atomic_async_commit hooks. New users of this 367 * flag are not allowed. 368 */ 369 bool legacy_cursor_update : 1; 370 bool async_update : 1; 371 /** 372 * @duplicated: 373 * 374 * Indicates whether or not this atomic state was duplicated using 375 * drm_atomic_helper_duplicate_state(). Drivers and atomic helpers 376 * should use this to fixup normal inconsistencies in duplicated 377 * states. 378 */ 379 bool duplicated : 1; 380 struct __drm_planes_state *planes; 381 struct __drm_crtcs_state *crtcs; 382 int num_connector; 383 struct __drm_connnectors_state *connectors; 384 int num_private_objs; 385 struct __drm_private_objs_state *private_objs; 386 387 struct drm_modeset_acquire_ctx *acquire_ctx; 388 389 /** 390 * @fake_commit: 391 * 392 * Used for signaling unbound planes/connectors. 393 * When a connector or plane is not bound to any CRTC, it's still important 394 * to preserve linearity to prevent the atomic states from being freed to early. 395 * 396 * This commit (if set) is not bound to any CRTC, but will be completed when 397 * drm_atomic_helper_commit_hw_done() is called. 398 */ 399 struct drm_crtc_commit *fake_commit; 400 401 /** 402 * @commit_work: 403 * 404 * Work item which can be used by the driver or helpers to execute the 405 * commit without blocking. 406 */ 407 struct work_struct commit_work; 408 }; 409 410 void __drm_crtc_commit_free(struct kref *kref); 411 412 /** 413 * drm_crtc_commit_get - acquire a reference to the CRTC commit 414 * @commit: CRTC commit 415 * 416 * Increases the reference of @commit. 417 * 418 * Returns: 419 * The pointer to @commit, with reference increased. 420 */ 421 static inline struct drm_crtc_commit *drm_crtc_commit_get(struct drm_crtc_commit *commit) 422 { 423 kref_get(&commit->ref); 424 return commit; 425 } 426 427 /** 428 * drm_crtc_commit_put - release a reference to the CRTC commmit 429 * @commit: CRTC commit 430 * 431 * This releases a reference to @commit which is freed after removing the 432 * final reference. No locking required and callable from any context. 433 */ 434 static inline void drm_crtc_commit_put(struct drm_crtc_commit *commit) 435 { 436 kref_put(&commit->ref, __drm_crtc_commit_free); 437 } 438 439 struct drm_atomic_state * __must_check 440 drm_atomic_state_alloc(struct drm_device *dev); 441 void drm_atomic_state_clear(struct drm_atomic_state *state); 442 443 /** 444 * drm_atomic_state_get - acquire a reference to the atomic state 445 * @state: The atomic state 446 * 447 * Returns a new reference to the @state 448 */ 449 static inline struct drm_atomic_state * 450 drm_atomic_state_get(struct drm_atomic_state *state) 451 { 452 kref_get(&state->ref); 453 return state; 454 } 455 456 void __drm_atomic_state_free(struct kref *ref); 457 458 /** 459 * drm_atomic_state_put - release a reference to the atomic state 460 * @state: The atomic state 461 * 462 * This releases a reference to @state which is freed after removing the 463 * final reference. No locking required and callable from any context. 464 */ 465 static inline void drm_atomic_state_put(struct drm_atomic_state *state) 466 { 467 kref_put(&state->ref, __drm_atomic_state_free); 468 } 469 470 int __must_check 471 drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state); 472 void drm_atomic_state_default_clear(struct drm_atomic_state *state); 473 void drm_atomic_state_default_release(struct drm_atomic_state *state); 474 475 struct drm_crtc_state * __must_check 476 drm_atomic_get_crtc_state(struct drm_atomic_state *state, 477 struct drm_crtc *crtc); 478 struct drm_plane_state * __must_check 479 drm_atomic_get_plane_state(struct drm_atomic_state *state, 480 struct drm_plane *plane); 481 struct drm_connector_state * __must_check 482 drm_atomic_get_connector_state(struct drm_atomic_state *state, 483 struct drm_connector *connector); 484 485 void drm_atomic_private_obj_init(struct drm_device *dev, 486 struct drm_private_obj *obj, 487 struct drm_private_state *state, 488 const struct drm_private_state_funcs *funcs); 489 void drm_atomic_private_obj_fini(struct drm_private_obj *obj); 490 491 struct drm_private_state * __must_check 492 drm_atomic_get_private_obj_state(struct drm_atomic_state *state, 493 struct drm_private_obj *obj); 494 struct drm_private_state * 495 drm_atomic_get_old_private_obj_state(struct drm_atomic_state *state, 496 struct drm_private_obj *obj); 497 struct drm_private_state * 498 drm_atomic_get_new_private_obj_state(struct drm_atomic_state *state, 499 struct drm_private_obj *obj); 500 501 struct drm_connector * 502 drm_atomic_get_old_connector_for_encoder(struct drm_atomic_state *state, 503 struct drm_encoder *encoder); 504 struct drm_connector * 505 drm_atomic_get_new_connector_for_encoder(struct drm_atomic_state *state, 506 struct drm_encoder *encoder); 507 508 /** 509 * drm_atomic_get_existing_crtc_state - get CRTC state, if it exists 510 * @state: global atomic state object 511 * @crtc: CRTC to grab 512 * 513 * This function returns the CRTC state for the given CRTC, or NULL 514 * if the CRTC is not part of the global atomic state. 515 * 516 * This function is deprecated, @drm_atomic_get_old_crtc_state or 517 * @drm_atomic_get_new_crtc_state should be used instead. 518 */ 519 static inline struct drm_crtc_state * 520 drm_atomic_get_existing_crtc_state(struct drm_atomic_state *state, 521 struct drm_crtc *crtc) 522 { 523 return state->crtcs[drm_crtc_index(crtc)].state; 524 } 525 526 /** 527 * drm_atomic_get_old_crtc_state - get old CRTC state, if it exists 528 * @state: global atomic state object 529 * @crtc: CRTC to grab 530 * 531 * This function returns the old CRTC state for the given CRTC, or 532 * NULL if the CRTC is not part of the global atomic state. 533 */ 534 static inline struct drm_crtc_state * 535 drm_atomic_get_old_crtc_state(struct drm_atomic_state *state, 536 struct drm_crtc *crtc) 537 { 538 return state->crtcs[drm_crtc_index(crtc)].old_state; 539 } 540 /** 541 * drm_atomic_get_new_crtc_state - get new CRTC state, if it exists 542 * @state: global atomic state object 543 * @crtc: CRTC to grab 544 * 545 * This function returns the new CRTC state for the given CRTC, or 546 * NULL if the CRTC is not part of the global atomic state. 547 */ 548 static inline struct drm_crtc_state * 549 drm_atomic_get_new_crtc_state(struct drm_atomic_state *state, 550 struct drm_crtc *crtc) 551 { 552 return state->crtcs[drm_crtc_index(crtc)].new_state; 553 } 554 555 /** 556 * drm_atomic_get_existing_plane_state - get plane state, if it exists 557 * @state: global atomic state object 558 * @plane: plane to grab 559 * 560 * This function returns the plane state for the given plane, or NULL 561 * if the plane is not part of the global atomic state. 562 * 563 * This function is deprecated, @drm_atomic_get_old_plane_state or 564 * @drm_atomic_get_new_plane_state should be used instead. 565 */ 566 static inline struct drm_plane_state * 567 drm_atomic_get_existing_plane_state(struct drm_atomic_state *state, 568 struct drm_plane *plane) 569 { 570 return state->planes[drm_plane_index(plane)].state; 571 } 572 573 /** 574 * drm_atomic_get_old_plane_state - get plane state, if it exists 575 * @state: global atomic state object 576 * @plane: plane to grab 577 * 578 * This function returns the old plane state for the given plane, or 579 * NULL if the plane is not part of the global atomic state. 580 */ 581 static inline struct drm_plane_state * 582 drm_atomic_get_old_plane_state(struct drm_atomic_state *state, 583 struct drm_plane *plane) 584 { 585 return state->planes[drm_plane_index(plane)].old_state; 586 } 587 588 /** 589 * drm_atomic_get_new_plane_state - get plane state, if it exists 590 * @state: global atomic state object 591 * @plane: plane to grab 592 * 593 * This function returns the new plane state for the given plane, or 594 * NULL if the plane is not part of the global atomic state. 595 */ 596 static inline struct drm_plane_state * 597 drm_atomic_get_new_plane_state(struct drm_atomic_state *state, 598 struct drm_plane *plane) 599 { 600 return state->planes[drm_plane_index(plane)].new_state; 601 } 602 603 /** 604 * drm_atomic_get_existing_connector_state - get connector state, if it exists 605 * @state: global atomic state object 606 * @connector: connector to grab 607 * 608 * This function returns the connector state for the given connector, 609 * or NULL if the connector is not part of the global atomic state. 610 * 611 * This function is deprecated, @drm_atomic_get_old_connector_state or 612 * @drm_atomic_get_new_connector_state should be used instead. 613 */ 614 static inline struct drm_connector_state * 615 drm_atomic_get_existing_connector_state(struct drm_atomic_state *state, 616 struct drm_connector *connector) 617 { 618 int index = drm_connector_index(connector); 619 620 if (index >= state->num_connector) 621 return NULL; 622 623 return state->connectors[index].state; 624 } 625 626 /** 627 * drm_atomic_get_old_connector_state - get connector state, if it exists 628 * @state: global atomic state object 629 * @connector: connector to grab 630 * 631 * This function returns the old connector state for the given connector, 632 * or NULL if the connector is not part of the global atomic state. 633 */ 634 static inline struct drm_connector_state * 635 drm_atomic_get_old_connector_state(struct drm_atomic_state *state, 636 struct drm_connector *connector) 637 { 638 int index = drm_connector_index(connector); 639 640 if (index >= state->num_connector) 641 return NULL; 642 643 return state->connectors[index].old_state; 644 } 645 646 /** 647 * drm_atomic_get_new_connector_state - get connector state, if it exists 648 * @state: global atomic state object 649 * @connector: connector to grab 650 * 651 * This function returns the new connector state for the given connector, 652 * or NULL if the connector is not part of the global atomic state. 653 */ 654 static inline struct drm_connector_state * 655 drm_atomic_get_new_connector_state(struct drm_atomic_state *state, 656 struct drm_connector *connector) 657 { 658 int index = drm_connector_index(connector); 659 660 if (index >= state->num_connector) 661 return NULL; 662 663 return state->connectors[index].new_state; 664 } 665 666 /** 667 * __drm_atomic_get_current_plane_state - get current plane state 668 * @state: global atomic state object 669 * @plane: plane to grab 670 * 671 * This function returns the plane state for the given plane, either from 672 * @state, or if the plane isn't part of the atomic state update, from @plane. 673 * This is useful in atomic check callbacks, when drivers need to peek at, but 674 * not change, state of other planes, since it avoids threading an error code 675 * back up the call chain. 676 * 677 * WARNING: 678 * 679 * Note that this function is in general unsafe since it doesn't check for the 680 * required locking for access state structures. Drivers must ensure that it is 681 * safe to access the returned state structure through other means. One common 682 * example is when planes are fixed to a single CRTC, and the driver knows that 683 * the CRTC lock is held already. In that case holding the CRTC lock gives a 684 * read-lock on all planes connected to that CRTC. But if planes can be 685 * reassigned things get more tricky. In that case it's better to use 686 * drm_atomic_get_plane_state and wire up full error handling. 687 * 688 * Returns: 689 * 690 * Read-only pointer to the current plane state. 691 */ 692 static inline const struct drm_plane_state * 693 __drm_atomic_get_current_plane_state(struct drm_atomic_state *state, 694 struct drm_plane *plane) 695 { 696 if (state->planes[drm_plane_index(plane)].state) 697 return state->planes[drm_plane_index(plane)].state; 698 699 return plane->state; 700 } 701 702 int __must_check 703 drm_atomic_add_encoder_bridges(struct drm_atomic_state *state, 704 struct drm_encoder *encoder); 705 int __must_check 706 drm_atomic_add_affected_connectors(struct drm_atomic_state *state, 707 struct drm_crtc *crtc); 708 int __must_check 709 drm_atomic_add_affected_planes(struct drm_atomic_state *state, 710 struct drm_crtc *crtc); 711 712 int __must_check drm_atomic_check_only(struct drm_atomic_state *state); 713 int __must_check drm_atomic_commit(struct drm_atomic_state *state); 714 int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_state *state); 715 716 void drm_state_dump(struct drm_device *dev, struct drm_printer *p); 717 718 /** 719 * for_each_oldnew_connector_in_state - iterate over all connectors in an atomic update 720 * @__state: &struct drm_atomic_state pointer 721 * @connector: &struct drm_connector iteration cursor 722 * @old_connector_state: &struct drm_connector_state iteration cursor for the 723 * old state 724 * @new_connector_state: &struct drm_connector_state iteration cursor for the 725 * new state 726 * @__i: int iteration cursor, for macro-internal use 727 * 728 * This iterates over all connectors in an atomic update, tracking both old and 729 * new state. This is useful in places where the state delta needs to be 730 * considered, for example in atomic check functions. 731 */ 732 #define for_each_oldnew_connector_in_state(__state, connector, old_connector_state, new_connector_state, __i) \ 733 for ((__i) = 0; \ 734 (__i) < (__state)->num_connector; \ 735 (__i)++) \ 736 for_each_if ((__state)->connectors[__i].ptr && \ 737 ((connector) = (__state)->connectors[__i].ptr, \ 738 (void)(connector) /* Only to avoid unused-but-set-variable warning */, \ 739 (old_connector_state) = (__state)->connectors[__i].old_state, \ 740 (new_connector_state) = (__state)->connectors[__i].new_state, 1)) 741 742 /** 743 * for_each_old_connector_in_state - iterate over all connectors in an atomic update 744 * @__state: &struct drm_atomic_state pointer 745 * @connector: &struct drm_connector iteration cursor 746 * @old_connector_state: &struct drm_connector_state iteration cursor for the 747 * old state 748 * @__i: int iteration cursor, for macro-internal use 749 * 750 * This iterates over all connectors in an atomic update, tracking only the old 751 * state. This is useful in disable functions, where we need the old state the 752 * hardware is still in. 753 */ 754 #define for_each_old_connector_in_state(__state, connector, old_connector_state, __i) \ 755 for ((__i) = 0; \ 756 (__i) < (__state)->num_connector; \ 757 (__i)++) \ 758 for_each_if ((__state)->connectors[__i].ptr && \ 759 ((connector) = (__state)->connectors[__i].ptr, \ 760 (void)(connector) /* Only to avoid unused-but-set-variable warning */, \ 761 (old_connector_state) = (__state)->connectors[__i].old_state, 1)) 762 763 /** 764 * for_each_new_connector_in_state - iterate over all connectors in an atomic update 765 * @__state: &struct drm_atomic_state pointer 766 * @connector: &struct drm_connector iteration cursor 767 * @new_connector_state: &struct drm_connector_state iteration cursor for the 768 * new state 769 * @__i: int iteration cursor, for macro-internal use 770 * 771 * This iterates over all connectors in an atomic update, tracking only the new 772 * state. This is useful in enable functions, where we need the new state the 773 * hardware should be in when the atomic commit operation has completed. 774 */ 775 #define for_each_new_connector_in_state(__state, connector, new_connector_state, __i) \ 776 for ((__i) = 0; \ 777 (__i) < (__state)->num_connector; \ 778 (__i)++) \ 779 for_each_if ((__state)->connectors[__i].ptr && \ 780 ((connector) = (__state)->connectors[__i].ptr, \ 781 (void)(connector) /* Only to avoid unused-but-set-variable warning */, \ 782 (new_connector_state) = (__state)->connectors[__i].new_state, \ 783 (void)(new_connector_state) /* Only to avoid unused-but-set-variable warning */, 1)) 784 785 /** 786 * for_each_oldnew_crtc_in_state - iterate over all CRTCs in an atomic update 787 * @__state: &struct drm_atomic_state pointer 788 * @crtc: &struct drm_crtc iteration cursor 789 * @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state 790 * @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state 791 * @__i: int iteration cursor, for macro-internal use 792 * 793 * This iterates over all CRTCs in an atomic update, tracking both old and 794 * new state. This is useful in places where the state delta needs to be 795 * considered, for example in atomic check functions. 796 */ 797 #define for_each_oldnew_crtc_in_state(__state, crtc, old_crtc_state, new_crtc_state, __i) \ 798 for ((__i) = 0; \ 799 (__i) < (__state)->dev->mode_config.num_crtc; \ 800 (__i)++) \ 801 for_each_if ((__state)->crtcs[__i].ptr && \ 802 ((crtc) = (__state)->crtcs[__i].ptr, \ 803 (void)(crtc) /* Only to avoid unused-but-set-variable warning */, \ 804 (old_crtc_state) = (__state)->crtcs[__i].old_state, \ 805 (void)(old_crtc_state) /* Only to avoid unused-but-set-variable warning */, \ 806 (new_crtc_state) = (__state)->crtcs[__i].new_state, \ 807 (void)(new_crtc_state) /* Only to avoid unused-but-set-variable warning */, 1)) 808 809 /** 810 * for_each_old_crtc_in_state - iterate over all CRTCs in an atomic update 811 * @__state: &struct drm_atomic_state pointer 812 * @crtc: &struct drm_crtc iteration cursor 813 * @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state 814 * @__i: int iteration cursor, for macro-internal use 815 * 816 * This iterates over all CRTCs in an atomic update, tracking only the old 817 * state. This is useful in disable functions, where we need the old state the 818 * hardware is still in. 819 */ 820 #define for_each_old_crtc_in_state(__state, crtc, old_crtc_state, __i) \ 821 for ((__i) = 0; \ 822 (__i) < (__state)->dev->mode_config.num_crtc; \ 823 (__i)++) \ 824 for_each_if ((__state)->crtcs[__i].ptr && \ 825 ((crtc) = (__state)->crtcs[__i].ptr, \ 826 (void)(crtc) /* Only to avoid unused-but-set-variable warning */, \ 827 (old_crtc_state) = (__state)->crtcs[__i].old_state, 1)) 828 829 /** 830 * for_each_new_crtc_in_state - iterate over all CRTCs in an atomic update 831 * @__state: &struct drm_atomic_state pointer 832 * @crtc: &struct drm_crtc iteration cursor 833 * @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state 834 * @__i: int iteration cursor, for macro-internal use 835 * 836 * This iterates over all CRTCs in an atomic update, tracking only the new 837 * state. This is useful in enable functions, where we need the new state the 838 * hardware should be in when the atomic commit operation has completed. 839 */ 840 #define for_each_new_crtc_in_state(__state, crtc, new_crtc_state, __i) \ 841 for ((__i) = 0; \ 842 (__i) < (__state)->dev->mode_config.num_crtc; \ 843 (__i)++) \ 844 for_each_if ((__state)->crtcs[__i].ptr && \ 845 ((crtc) = (__state)->crtcs[__i].ptr, \ 846 (void)(crtc) /* Only to avoid unused-but-set-variable warning */, \ 847 (new_crtc_state) = (__state)->crtcs[__i].new_state, \ 848 (void)(new_crtc_state) /* Only to avoid unused-but-set-variable warning */, 1)) 849 850 /** 851 * for_each_oldnew_plane_in_state - iterate over all planes in an atomic update 852 * @__state: &struct drm_atomic_state pointer 853 * @plane: &struct drm_plane iteration cursor 854 * @old_plane_state: &struct drm_plane_state iteration cursor for the old state 855 * @new_plane_state: &struct drm_plane_state iteration cursor for the new state 856 * @__i: int iteration cursor, for macro-internal use 857 * 858 * This iterates over all planes in an atomic update, tracking both old and 859 * new state. This is useful in places where the state delta needs to be 860 * considered, for example in atomic check functions. 861 */ 862 #define for_each_oldnew_plane_in_state(__state, plane, old_plane_state, new_plane_state, __i) \ 863 for ((__i) = 0; \ 864 (__i) < (__state)->dev->mode_config.num_total_plane; \ 865 (__i)++) \ 866 for_each_if ((__state)->planes[__i].ptr && \ 867 ((plane) = (__state)->planes[__i].ptr, \ 868 (void)(plane) /* Only to avoid unused-but-set-variable warning */, \ 869 (old_plane_state) = (__state)->planes[__i].old_state,\ 870 (new_plane_state) = (__state)->planes[__i].new_state, 1)) 871 872 /** 873 * for_each_oldnew_plane_in_state_reverse - iterate over all planes in an atomic 874 * update in reverse order 875 * @__state: &struct drm_atomic_state pointer 876 * @plane: &struct drm_plane iteration cursor 877 * @old_plane_state: &struct drm_plane_state iteration cursor for the old state 878 * @new_plane_state: &struct drm_plane_state iteration cursor for the new state 879 * @__i: int iteration cursor, for macro-internal use 880 * 881 * This iterates over all planes in an atomic update in reverse order, 882 * tracking both old and new state. This is useful in places where the 883 * state delta needs to be considered, for example in atomic check functions. 884 */ 885 #define for_each_oldnew_plane_in_state_reverse(__state, plane, old_plane_state, new_plane_state, __i) \ 886 for ((__i) = ((__state)->dev->mode_config.num_total_plane - 1); \ 887 (__i) >= 0; \ 888 (__i)--) \ 889 for_each_if ((__state)->planes[__i].ptr && \ 890 ((plane) = (__state)->planes[__i].ptr, \ 891 (old_plane_state) = (__state)->planes[__i].old_state,\ 892 (new_plane_state) = (__state)->planes[__i].new_state, 1)) 893 894 /** 895 * for_each_old_plane_in_state - iterate over all planes in an atomic update 896 * @__state: &struct drm_atomic_state pointer 897 * @plane: &struct drm_plane iteration cursor 898 * @old_plane_state: &struct drm_plane_state iteration cursor for the old state 899 * @__i: int iteration cursor, for macro-internal use 900 * 901 * This iterates over all planes in an atomic update, tracking only the old 902 * state. This is useful in disable functions, where we need the old state the 903 * hardware is still in. 904 */ 905 #define for_each_old_plane_in_state(__state, plane, old_plane_state, __i) \ 906 for ((__i) = 0; \ 907 (__i) < (__state)->dev->mode_config.num_total_plane; \ 908 (__i)++) \ 909 for_each_if ((__state)->planes[__i].ptr && \ 910 ((plane) = (__state)->planes[__i].ptr, \ 911 (old_plane_state) = (__state)->planes[__i].old_state, 1)) 912 /** 913 * for_each_new_plane_in_state - iterate over all planes in an atomic update 914 * @__state: &struct drm_atomic_state pointer 915 * @plane: &struct drm_plane iteration cursor 916 * @new_plane_state: &struct drm_plane_state iteration cursor for the new state 917 * @__i: int iteration cursor, for macro-internal use 918 * 919 * This iterates over all planes in an atomic update, tracking only the new 920 * state. This is useful in enable functions, where we need the new state the 921 * hardware should be in when the atomic commit operation has completed. 922 */ 923 #define for_each_new_plane_in_state(__state, plane, new_plane_state, __i) \ 924 for ((__i) = 0; \ 925 (__i) < (__state)->dev->mode_config.num_total_plane; \ 926 (__i)++) \ 927 for_each_if ((__state)->planes[__i].ptr && \ 928 ((plane) = (__state)->planes[__i].ptr, \ 929 (void)(plane) /* Only to avoid unused-but-set-variable warning */, \ 930 (new_plane_state) = (__state)->planes[__i].new_state, \ 931 (void)(new_plane_state) /* Only to avoid unused-but-set-variable warning */, 1)) 932 933 /** 934 * for_each_oldnew_private_obj_in_state - iterate over all private objects in an atomic update 935 * @__state: &struct drm_atomic_state pointer 936 * @obj: &struct drm_private_obj iteration cursor 937 * @old_obj_state: &struct drm_private_state iteration cursor for the old state 938 * @new_obj_state: &struct drm_private_state iteration cursor for the new state 939 * @__i: int iteration cursor, for macro-internal use 940 * 941 * This iterates over all private objects in an atomic update, tracking both 942 * old and new state. This is useful in places where the state delta needs 943 * to be considered, for example in atomic check functions. 944 */ 945 #define for_each_oldnew_private_obj_in_state(__state, obj, old_obj_state, new_obj_state, __i) \ 946 for ((__i) = 0; \ 947 (__i) < (__state)->num_private_objs && \ 948 ((obj) = (__state)->private_objs[__i].ptr, \ 949 (old_obj_state) = (__state)->private_objs[__i].old_state, \ 950 (new_obj_state) = (__state)->private_objs[__i].new_state, 1); \ 951 (__i)++) 952 953 /** 954 * for_each_old_private_obj_in_state - iterate over all private objects in an atomic update 955 * @__state: &struct drm_atomic_state pointer 956 * @obj: &struct drm_private_obj iteration cursor 957 * @old_obj_state: &struct drm_private_state iteration cursor for the old state 958 * @__i: int iteration cursor, for macro-internal use 959 * 960 * This iterates over all private objects in an atomic update, tracking only 961 * the old state. This is useful in disable functions, where we need the old 962 * state the hardware is still in. 963 */ 964 #define for_each_old_private_obj_in_state(__state, obj, old_obj_state, __i) \ 965 for ((__i) = 0; \ 966 (__i) < (__state)->num_private_objs && \ 967 ((obj) = (__state)->private_objs[__i].ptr, \ 968 (old_obj_state) = (__state)->private_objs[__i].old_state, 1); \ 969 (__i)++) 970 971 /** 972 * for_each_new_private_obj_in_state - iterate over all private objects in an atomic update 973 * @__state: &struct drm_atomic_state pointer 974 * @obj: &struct drm_private_obj iteration cursor 975 * @new_obj_state: &struct drm_private_state iteration cursor for the new state 976 * @__i: int iteration cursor, for macro-internal use 977 * 978 * This iterates over all private objects in an atomic update, tracking only 979 * the new state. This is useful in enable functions, where we need the new state the 980 * hardware should be in when the atomic commit operation has completed. 981 */ 982 #define for_each_new_private_obj_in_state(__state, obj, new_obj_state, __i) \ 983 for ((__i) = 0; \ 984 (__i) < (__state)->num_private_objs && \ 985 ((obj) = (__state)->private_objs[__i].ptr, \ 986 (new_obj_state) = (__state)->private_objs[__i].new_state, 1); \ 987 (__i)++) 988 989 /** 990 * drm_atomic_crtc_needs_modeset - compute combined modeset need 991 * @state: &drm_crtc_state for the CRTC 992 * 993 * To give drivers flexibility &struct drm_crtc_state has 3 booleans to track 994 * whether the state CRTC changed enough to need a full modeset cycle: 995 * mode_changed, active_changed and connectors_changed. This helper simply 996 * combines these three to compute the overall need for a modeset for @state. 997 * 998 * The atomic helper code sets these booleans, but drivers can and should 999 * change them appropriately to accurately represent whether a modeset is 1000 * really needed. In general, drivers should avoid full modesets whenever 1001 * possible. 1002 * 1003 * For example if the CRTC mode has changed, and the hardware is able to enact 1004 * the requested mode change without going through a full modeset, the driver 1005 * should clear mode_changed in its &drm_mode_config_funcs.atomic_check 1006 * implementation. 1007 */ 1008 static inline bool 1009 drm_atomic_crtc_needs_modeset(const struct drm_crtc_state *state) 1010 { 1011 return state->mode_changed || state->active_changed || 1012 state->connectors_changed; 1013 } 1014 1015 /** 1016 * drm_atomic_crtc_effectively_active - compute whether CRTC is actually active 1017 * @state: &drm_crtc_state for the CRTC 1018 * 1019 * When in self refresh mode, the crtc_state->active value will be false, since 1020 * the CRTC is off. However in some cases we're interested in whether the CRTC 1021 * is active, or effectively active (ie: it's connected to an active display). 1022 * In these cases, use this function instead of just checking active. 1023 */ 1024 static inline bool 1025 drm_atomic_crtc_effectively_active(const struct drm_crtc_state *state) 1026 { 1027 return state->active || state->self_refresh_active; 1028 } 1029 1030 /** 1031 * struct drm_bus_cfg - bus configuration 1032 * 1033 * This structure stores the configuration of a physical bus between two 1034 * components in an output pipeline, usually between two bridges, an encoder 1035 * and a bridge, or a bridge and a connector. 1036 * 1037 * The bus configuration is stored in &drm_bridge_state separately for the 1038 * input and output buses, as seen from the point of view of each bridge. The 1039 * bus configuration of a bridge output is usually identical to the 1040 * configuration of the next bridge's input, but may differ if the signals are 1041 * modified between the two bridges, for instance by an inverter on the board. 1042 * The input and output configurations of a bridge may differ if the bridge 1043 * modifies the signals internally, for instance by performing format 1044 * conversion, or modifying signals polarities. 1045 */ 1046 struct drm_bus_cfg { 1047 /** 1048 * @format: format used on this bus (one of the MEDIA_BUS_FMT_* format) 1049 * 1050 * This field should not be directly modified by drivers 1051 * (drm_atomic_bridge_chain_select_bus_fmts() takes care of the bus 1052 * format negotiation). 1053 */ 1054 u32 format; 1055 1056 /** 1057 * @flags: DRM_BUS_* flags used on this bus 1058 */ 1059 u32 flags; 1060 }; 1061 1062 /** 1063 * struct drm_bridge_state - Atomic bridge state object 1064 */ 1065 struct drm_bridge_state { 1066 /** 1067 * @base: inherit from &drm_private_state 1068 */ 1069 struct drm_private_state base; 1070 1071 /** 1072 * @bridge: the bridge this state refers to 1073 */ 1074 struct drm_bridge *bridge; 1075 1076 /** 1077 * @input_bus_cfg: input bus configuration 1078 */ 1079 struct drm_bus_cfg input_bus_cfg; 1080 1081 /** 1082 * @output_bus_cfg: input bus configuration 1083 */ 1084 struct drm_bus_cfg output_bus_cfg; 1085 }; 1086 1087 static inline struct drm_bridge_state * 1088 drm_priv_to_bridge_state(struct drm_private_state *priv) 1089 { 1090 return container_of(priv, struct drm_bridge_state, base); 1091 } 1092 1093 struct drm_bridge_state * 1094 drm_atomic_get_bridge_state(struct drm_atomic_state *state, 1095 struct drm_bridge *bridge); 1096 struct drm_bridge_state * 1097 drm_atomic_get_old_bridge_state(struct drm_atomic_state *state, 1098 struct drm_bridge *bridge); 1099 struct drm_bridge_state * 1100 drm_atomic_get_new_bridge_state(struct drm_atomic_state *state, 1101 struct drm_bridge *bridge); 1102 1103 #endif /* DRM_ATOMIC_H_ */ 1104