1 /* 2 * Copyright © 2006 Keith Packard 3 * Copyright © 2007-2008 Dave Airlie 4 * Copyright © 2007-2008 Intel Corporation 5 * Jesse Barnes <jesse.barnes@intel.com> 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included in 15 * all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 * OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 #ifndef __DRM_CRTC_H__ 26 #define __DRM_CRTC_H__ 27 28 #include <linux/i2c.h> 29 #include <linux/spinlock.h> 30 #include <linux/types.h> 31 #include <linux/fb.h> 32 #include <linux/hdmi.h> 33 #include <linux/media-bus-format.h> 34 #include <uapi/drm/drm_mode.h> 35 #include <uapi/drm/drm_fourcc.h> 36 #include <drm/drm_modeset_lock.h> 37 #include <drm/drm_rect.h> 38 #include <drm/drm_mode_object.h> 39 #include <drm/drm_framebuffer.h> 40 #include <drm/drm_modes.h> 41 #include <drm/drm_connector.h> 42 #include <drm/drm_encoder.h> 43 #include <drm/drm_property.h> 44 #include <drm/drm_bridge.h> 45 #include <drm/drm_edid.h> 46 #include <drm/drm_plane.h> 47 #include <drm/drm_blend.h> 48 #include <drm/drm_color_mgmt.h> 49 #include <drm/drm_debugfs_crc.h> 50 #include <drm/drm_mode_config.h> 51 52 struct drm_device; 53 struct drm_mode_set; 54 struct drm_file; 55 struct drm_clip_rect; 56 struct drm_printer; 57 struct device_node; 58 struct dma_fence; 59 struct edid; 60 61 static inline int64_t U642I64(uint64_t val) 62 { 63 return (int64_t)*((int64_t *)&val); 64 } 65 static inline uint64_t I642U64(int64_t val) 66 { 67 return (uint64_t)*((uint64_t *)&val); 68 } 69 70 struct drm_crtc; 71 struct drm_encoder; 72 struct drm_pending_vblank_event; 73 struct drm_plane; 74 struct drm_bridge; 75 struct drm_atomic_state; 76 77 struct drm_crtc_helper_funcs; 78 struct drm_encoder_helper_funcs; 79 struct drm_plane_helper_funcs; 80 81 /** 82 * struct drm_crtc_state - mutable CRTC state 83 * @crtc: backpointer to the CRTC 84 * @enable: whether the CRTC should be enabled, gates all other state 85 * @active: whether the CRTC is actively displaying (used for DPMS) 86 * @planes_changed: planes on this crtc are updated 87 * @mode_changed: crtc_state->mode or crtc_state->enable has been changed 88 * @active_changed: crtc_state->active has been toggled. 89 * @connectors_changed: connectors to this crtc have been updated 90 * @zpos_changed: zpos values of planes on this crtc have been updated 91 * @color_mgmt_changed: color management properties have changed (degamma or 92 * gamma LUT or CSC matrix) 93 * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes 94 * @connector_mask: bitmask of (1 << drm_connector_index(connector)) of attached connectors 95 * @encoder_mask: bitmask of (1 << drm_encoder_index(encoder)) of attached encoders 96 * @last_vblank_count: for helpers and drivers to capture the vblank of the 97 * update to ensure framebuffer cleanup isn't done too early 98 * @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings 99 * @mode: current mode timings 100 * @mode_blob: &drm_property_blob for @mode 101 * @degamma_lut: Lookup table for converting framebuffer pixel data 102 * before apply the conversion matrix 103 * @ctm: Transformation matrix 104 * @gamma_lut: Lookup table for converting pixel data after the 105 * conversion matrix 106 * @state: backpointer to global drm_atomic_state 107 * 108 * Note that the distinction between @enable and @active is rather subtile: 109 * Flipping @active while @enable is set without changing anything else may 110 * never return in a failure from the ->atomic_check callback. Userspace assumes 111 * that a DPMS On will always succeed. In other words: @enable controls resource 112 * assignment, @active controls the actual hardware state. 113 * 114 * The three booleans active_changed, connectors_changed and mode_changed are 115 * intended to indicate whether a full modeset is needed, rather than strictly 116 * describing what has changed in a commit. 117 * See also: drm_atomic_crtc_needs_modeset() 118 */ 119 struct drm_crtc_state { 120 struct drm_crtc *crtc; 121 122 bool enable; 123 bool active; 124 125 /* computed state bits used by helpers and drivers */ 126 bool planes_changed : 1; 127 bool mode_changed : 1; 128 bool active_changed : 1; 129 bool connectors_changed : 1; 130 bool zpos_changed : 1; 131 bool color_mgmt_changed : 1; 132 133 /* attached planes bitmask: 134 * WARNING: transitional helpers do not maintain plane_mask so 135 * drivers not converted over to atomic helpers should not rely 136 * on plane_mask being accurate! 137 */ 138 u32 plane_mask; 139 140 u32 connector_mask; 141 u32 encoder_mask; 142 143 /* last_vblank_count: for vblank waits before cleanup */ 144 u32 last_vblank_count; 145 146 /* adjusted_mode: for use by helpers and drivers */ 147 struct drm_display_mode adjusted_mode; 148 149 struct drm_display_mode mode; 150 151 /* blob property to expose current mode to atomic userspace */ 152 struct drm_property_blob *mode_blob; 153 154 /* blob property to expose color management to userspace */ 155 struct drm_property_blob *degamma_lut; 156 struct drm_property_blob *ctm; 157 struct drm_property_blob *gamma_lut; 158 159 /** 160 * @event: 161 * 162 * Optional pointer to a DRM event to signal upon completion of the 163 * state update. The driver must send out the event when the atomic 164 * commit operation completes. There are two cases: 165 * 166 * - The event is for a CRTC which is being disabled through this 167 * atomic commit. In that case the event can be send out any time 168 * after the hardware has stopped scanning out the current 169 * framebuffers. It should contain the timestamp and counter for the 170 * last vblank before the display pipeline was shut off. 171 * 172 * - For a CRTC which is enabled at the end of the commit (even when it 173 * undergoes an full modeset) the vblank timestamp and counter must 174 * be for the vblank right before the first frame that scans out the 175 * new set of buffers. Again the event can only be sent out after the 176 * hardware has stopped scanning out the old buffers. 177 * 178 * - Events for disabled CRTCs are not allowed, and drivers can ignore 179 * that case. 180 * 181 * This can be handled by the drm_crtc_send_vblank_event() function, 182 * which the driver should call on the provided event upon completion of 183 * the atomic commit. Note that if the driver supports vblank signalling 184 * and timestamping the vblank counters and timestamps must agree with 185 * the ones returned from page flip events. With the current vblank 186 * helper infrastructure this can be achieved by holding a vblank 187 * reference while the page flip is pending, acquired through 188 * drm_crtc_vblank_get() and released with drm_crtc_vblank_put(). 189 * Drivers are free to implement their own vblank counter and timestamp 190 * tracking though, e.g. if they have accurate timestamp registers in 191 * hardware. 192 * 193 * For hardware which supports some means to synchronize vblank 194 * interrupt delivery with committing display state there's also 195 * drm_crtc_arm_vblank_event(). See the documentation of that function 196 * for a detailed discussion of the constraints it needs to be used 197 * safely. 198 */ 199 struct drm_pending_vblank_event *event; 200 201 struct drm_atomic_state *state; 202 }; 203 204 /** 205 * struct drm_crtc_funcs - control CRTCs for a given device 206 * 207 * The drm_crtc_funcs structure is the central CRTC management structure 208 * in the DRM. Each CRTC controls one or more connectors (note that the name 209 * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc. 210 * connectors, not just CRTs). 211 * 212 * Each driver is responsible for filling out this structure at startup time, 213 * in addition to providing other modesetting features, like i2c and DDC 214 * bus accessors. 215 */ 216 struct drm_crtc_funcs { 217 /** 218 * @reset: 219 * 220 * Reset CRTC hardware and software state to off. This function isn't 221 * called by the core directly, only through drm_mode_config_reset(). 222 * It's not a helper hook only for historical reasons. 223 * 224 * Atomic drivers can use drm_atomic_helper_crtc_reset() to reset 225 * atomic state using this hook. 226 */ 227 void (*reset)(struct drm_crtc *crtc); 228 229 /** 230 * @cursor_set: 231 * 232 * Update the cursor image. The cursor position is relative to the CRTC 233 * and can be partially or fully outside of the visible area. 234 * 235 * Note that contrary to all other KMS functions the legacy cursor entry 236 * points don't take a framebuffer object, but instead take directly a 237 * raw buffer object id from the driver's buffer manager (which is 238 * either GEM or TTM for current drivers). 239 * 240 * This entry point is deprecated, drivers should instead implement 241 * universal plane support and register a proper cursor plane using 242 * drm_crtc_init_with_planes(). 243 * 244 * This callback is optional 245 * 246 * RETURNS: 247 * 248 * 0 on success or a negative error code on failure. 249 */ 250 int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv, 251 uint32_t handle, uint32_t width, uint32_t height); 252 253 /** 254 * @cursor_set2: 255 * 256 * Update the cursor image, including hotspot information. The hotspot 257 * must not affect the cursor position in CRTC coordinates, but is only 258 * meant as a hint for virtualized display hardware to coordinate the 259 * guests and hosts cursor position. The cursor hotspot is relative to 260 * the cursor image. Otherwise this works exactly like @cursor_set. 261 * 262 * This entry point is deprecated, drivers should instead implement 263 * universal plane support and register a proper cursor plane using 264 * drm_crtc_init_with_planes(). 265 * 266 * This callback is optional. 267 * 268 * RETURNS: 269 * 270 * 0 on success or a negative error code on failure. 271 */ 272 int (*cursor_set2)(struct drm_crtc *crtc, struct drm_file *file_priv, 273 uint32_t handle, uint32_t width, uint32_t height, 274 int32_t hot_x, int32_t hot_y); 275 276 /** 277 * @cursor_move: 278 * 279 * Update the cursor position. The cursor does not need to be visible 280 * when this hook is called. 281 * 282 * This entry point is deprecated, drivers should instead implement 283 * universal plane support and register a proper cursor plane using 284 * drm_crtc_init_with_planes(). 285 * 286 * This callback is optional. 287 * 288 * RETURNS: 289 * 290 * 0 on success or a negative error code on failure. 291 */ 292 int (*cursor_move)(struct drm_crtc *crtc, int x, int y); 293 294 /** 295 * @gamma_set: 296 * 297 * Set gamma on the CRTC. 298 * 299 * This callback is optional. 300 * 301 * NOTE: 302 * 303 * Drivers that support gamma tables and also fbdev emulation through 304 * the provided helper library need to take care to fill out the gamma 305 * hooks for both. Currently there's a bit an unfortunate duplication 306 * going on, which should eventually be unified to just one set of 307 * hooks. 308 */ 309 int (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b, 310 uint32_t size); 311 312 /** 313 * @destroy: 314 * 315 * Clean up plane resources. This is only called at driver unload time 316 * through drm_mode_config_cleanup() since a CRTC cannot be hotplugged 317 * in DRM. 318 */ 319 void (*destroy)(struct drm_crtc *crtc); 320 321 /** 322 * @set_config: 323 * 324 * This is the main legacy entry point to change the modeset state on a 325 * CRTC. All the details of the desired configuration are passed in a 326 * struct &drm_mode_set - see there for details. 327 * 328 * Drivers implementing atomic modeset should use 329 * drm_atomic_helper_set_config() to implement this hook. 330 * 331 * RETURNS: 332 * 333 * 0 on success or a negative error code on failure. 334 */ 335 int (*set_config)(struct drm_mode_set *set); 336 337 /** 338 * @page_flip: 339 * 340 * Legacy entry point to schedule a flip to the given framebuffer. 341 * 342 * Page flipping is a synchronization mechanism that replaces the frame 343 * buffer being scanned out by the CRTC with a new frame buffer during 344 * vertical blanking, avoiding tearing (except when requested otherwise 345 * through the DRM_MODE_PAGE_FLIP_ASYNC flag). When an application 346 * requests a page flip the DRM core verifies that the new frame buffer 347 * is large enough to be scanned out by the CRTC in the currently 348 * configured mode and then calls the CRTC ->page_flip() operation with a 349 * pointer to the new frame buffer. 350 * 351 * The driver must wait for any pending rendering to the new framebuffer 352 * to complete before executing the flip. It should also wait for any 353 * pending rendering from other drivers if the underlying buffer is a 354 * shared dma-buf. 355 * 356 * An application can request to be notified when the page flip has 357 * completed. The drm core will supply a struct &drm_event in the event 358 * parameter in this case. This can be handled by the 359 * drm_crtc_send_vblank_event() function, which the driver should call on 360 * the provided event upon completion of the flip. Note that if 361 * the driver supports vblank signalling and timestamping the vblank 362 * counters and timestamps must agree with the ones returned from page 363 * flip events. With the current vblank helper infrastructure this can 364 * be achieved by holding a vblank reference while the page flip is 365 * pending, acquired through drm_crtc_vblank_get() and released with 366 * drm_crtc_vblank_put(). Drivers are free to implement their own vblank 367 * counter and timestamp tracking though, e.g. if they have accurate 368 * timestamp registers in hardware. 369 * 370 * This callback is optional. 371 * 372 * NOTE: 373 * 374 * Very early versions of the KMS ABI mandated that the driver must 375 * block (but not reject) any rendering to the old framebuffer until the 376 * flip operation has completed and the old framebuffer is no longer 377 * visible. This requirement has been lifted, and userspace is instead 378 * expected to request delivery of an event and wait with recycling old 379 * buffers until such has been received. 380 * 381 * RETURNS: 382 * 383 * 0 on success or a negative error code on failure. Note that if a 384 * ->page_flip() operation is already pending the callback should return 385 * -EBUSY. Pageflips on a disabled CRTC (either by setting a NULL mode 386 * or just runtime disabled through DPMS respectively the new atomic 387 * "ACTIVE" state) should result in an -EINVAL error code. Note that 388 * drm_atomic_helper_page_flip() checks this already for atomic drivers. 389 */ 390 int (*page_flip)(struct drm_crtc *crtc, 391 struct drm_framebuffer *fb, 392 struct drm_pending_vblank_event *event, 393 uint32_t flags); 394 395 /** 396 * @page_flip_target: 397 * 398 * Same as @page_flip but with an additional parameter specifying the 399 * absolute target vertical blank period (as reported by 400 * drm_crtc_vblank_count()) when the flip should take effect. 401 * 402 * Note that the core code calls drm_crtc_vblank_get before this entry 403 * point, and will call drm_crtc_vblank_put if this entry point returns 404 * any non-0 error code. It's the driver's responsibility to call 405 * drm_crtc_vblank_put after this entry point returns 0, typically when 406 * the flip completes. 407 */ 408 int (*page_flip_target)(struct drm_crtc *crtc, 409 struct drm_framebuffer *fb, 410 struct drm_pending_vblank_event *event, 411 uint32_t flags, uint32_t target); 412 413 /** 414 * @set_property: 415 * 416 * This is the legacy entry point to update a property attached to the 417 * CRTC. 418 * 419 * Drivers implementing atomic modeset should use 420 * drm_atomic_helper_crtc_set_property() to implement this hook. 421 * 422 * This callback is optional if the driver does not support any legacy 423 * driver-private properties. 424 * 425 * RETURNS: 426 * 427 * 0 on success or a negative error code on failure. 428 */ 429 int (*set_property)(struct drm_crtc *crtc, 430 struct drm_property *property, uint64_t val); 431 432 /** 433 * @atomic_duplicate_state: 434 * 435 * Duplicate the current atomic state for this CRTC and return it. 436 * The core and helpers gurantee that any atomic state duplicated with 437 * this hook and still owned by the caller (i.e. not transferred to the 438 * driver by calling ->atomic_commit() from struct 439 * &drm_mode_config_funcs) will be cleaned up by calling the 440 * @atomic_destroy_state hook in this structure. 441 * 442 * Atomic drivers which don't subclass struct &drm_crtc should use 443 * drm_atomic_helper_crtc_duplicate_state(). Drivers that subclass the 444 * state structure to extend it with driver-private state should use 445 * __drm_atomic_helper_crtc_duplicate_state() to make sure shared state is 446 * duplicated in a consistent fashion across drivers. 447 * 448 * It is an error to call this hook before crtc->state has been 449 * initialized correctly. 450 * 451 * NOTE: 452 * 453 * If the duplicate state references refcounted resources this hook must 454 * acquire a reference for each of them. The driver must release these 455 * references again in @atomic_destroy_state. 456 * 457 * RETURNS: 458 * 459 * Duplicated atomic state or NULL when the allocation failed. 460 */ 461 struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc); 462 463 /** 464 * @atomic_destroy_state: 465 * 466 * Destroy a state duplicated with @atomic_duplicate_state and release 467 * or unreference all resources it references 468 */ 469 void (*atomic_destroy_state)(struct drm_crtc *crtc, 470 struct drm_crtc_state *state); 471 472 /** 473 * @atomic_set_property: 474 * 475 * Decode a driver-private property value and store the decoded value 476 * into the passed-in state structure. Since the atomic core decodes all 477 * standardized properties (even for extensions beyond the core set of 478 * properties which might not be implemented by all drivers) this 479 * requires drivers to subclass the state structure. 480 * 481 * Such driver-private properties should really only be implemented for 482 * truly hardware/vendor specific state. Instead it is preferred to 483 * standardize atomic extension and decode the properties used to expose 484 * such an extension in the core. 485 * 486 * Do not call this function directly, use 487 * drm_atomic_crtc_set_property() instead. 488 * 489 * This callback is optional if the driver does not support any 490 * driver-private atomic properties. 491 * 492 * NOTE: 493 * 494 * This function is called in the state assembly phase of atomic 495 * modesets, which can be aborted for any reason (including on 496 * userspace's request to just check whether a configuration would be 497 * possible). Drivers MUST NOT touch any persistent state (hardware or 498 * software) or data structures except the passed in @state parameter. 499 * 500 * Also since userspace controls in which order properties are set this 501 * function must not do any input validation (since the state update is 502 * incomplete and hence likely inconsistent). Instead any such input 503 * validation must be done in the various atomic_check callbacks. 504 * 505 * RETURNS: 506 * 507 * 0 if the property has been found, -EINVAL if the property isn't 508 * implemented by the driver (which should never happen, the core only 509 * asks for properties attached to this CRTC). No other validation is 510 * allowed by the driver. The core already checks that the property 511 * value is within the range (integer, valid enum value, ...) the driver 512 * set when registering the property. 513 */ 514 int (*atomic_set_property)(struct drm_crtc *crtc, 515 struct drm_crtc_state *state, 516 struct drm_property *property, 517 uint64_t val); 518 /** 519 * @atomic_get_property: 520 * 521 * Reads out the decoded driver-private property. This is used to 522 * implement the GETCRTC IOCTL. 523 * 524 * Do not call this function directly, use 525 * drm_atomic_crtc_get_property() instead. 526 * 527 * This callback is optional if the driver does not support any 528 * driver-private atomic properties. 529 * 530 * RETURNS: 531 * 532 * 0 on success, -EINVAL if the property isn't implemented by the 533 * driver (which should never happen, the core only asks for 534 * properties attached to this CRTC). 535 */ 536 int (*atomic_get_property)(struct drm_crtc *crtc, 537 const struct drm_crtc_state *state, 538 struct drm_property *property, 539 uint64_t *val); 540 541 /** 542 * @late_register: 543 * 544 * This optional hook can be used to register additional userspace 545 * interfaces attached to the crtc like debugfs interfaces. 546 * It is called late in the driver load sequence from drm_dev_register(). 547 * Everything added from this callback should be unregistered in 548 * the early_unregister callback. 549 * 550 * Returns: 551 * 552 * 0 on success, or a negative error code on failure. 553 */ 554 int (*late_register)(struct drm_crtc *crtc); 555 556 /** 557 * @early_unregister: 558 * 559 * This optional hook should be used to unregister the additional 560 * userspace interfaces attached to the crtc from 561 * late_unregister(). It is called from drm_dev_unregister(), 562 * early in the driver unload sequence to disable userspace access 563 * before data structures are torndown. 564 */ 565 void (*early_unregister)(struct drm_crtc *crtc); 566 567 /** 568 * @set_crc_source: 569 * 570 * Changes the source of CRC checksums of frames at the request of 571 * userspace, typically for testing purposes. The sources available are 572 * specific of each driver and a %NULL value indicates that CRC 573 * generation is to be switched off. 574 * 575 * When CRC generation is enabled, the driver should call 576 * drm_crtc_add_crc_entry() at each frame, providing any information 577 * that characterizes the frame contents in the crcN arguments, as 578 * provided from the configured source. Drivers must accept a "auto" 579 * source name that will select a default source for this CRTC. 580 * 581 * This callback is optional if the driver does not support any CRC 582 * generation functionality. 583 * 584 * RETURNS: 585 * 586 * 0 on success or a negative error code on failure. 587 */ 588 int (*set_crc_source)(struct drm_crtc *crtc, const char *source, 589 size_t *values_cnt); 590 591 /** 592 * @atomic_print_state: 593 * 594 * If driver subclasses struct &drm_crtc_state, it should implement 595 * this optional hook for printing additional driver specific state. 596 * 597 * Do not call this directly, use drm_atomic_crtc_print_state() 598 * instead. 599 */ 600 void (*atomic_print_state)(struct drm_printer *p, 601 const struct drm_crtc_state *state); 602 }; 603 604 /** 605 * struct drm_crtc - central CRTC control structure 606 * @dev: parent DRM device 607 * @port: OF node used by drm_of_find_possible_crtcs() 608 * @head: list management 609 * @name: human readable name, can be overwritten by the driver 610 * @mutex: per-CRTC locking 611 * @base: base KMS object for ID tracking etc. 612 * @primary: primary plane for this CRTC 613 * @cursor: cursor plane for this CRTC 614 * @cursor_x: current x position of the cursor, used for universal cursor planes 615 * @cursor_y: current y position of the cursor, used for universal cursor planes 616 * @enabled: is this CRTC enabled? 617 * @mode: current mode timings 618 * @hwmode: mode timings as programmed to hw regs 619 * @x: x position on screen 620 * @y: y position on screen 621 * @funcs: CRTC control functions 622 * @gamma_size: size of gamma ramp 623 * @gamma_store: gamma ramp values 624 * @helper_private: mid-layer private data 625 * @properties: property tracking for this CRTC 626 * 627 * Each CRTC may have one or more connectors associated with it. This structure 628 * allows the CRTC to be controlled. 629 */ 630 struct drm_crtc { 631 struct drm_device *dev; 632 struct device_node *port; 633 struct list_head head; 634 635 char *name; 636 637 /** 638 * @mutex: 639 * 640 * This provides a read lock for the overall crtc state (mode, dpms 641 * state, ...) and a write lock for everything which can be update 642 * without a full modeset (fb, cursor data, crtc properties ...). Full 643 * modeset also need to grab dev->mode_config.connection_mutex. 644 */ 645 struct drm_modeset_lock mutex; 646 647 struct drm_mode_object base; 648 649 /* primary and cursor planes for CRTC */ 650 struct drm_plane *primary; 651 struct drm_plane *cursor; 652 653 /** 654 * @index: Position inside the mode_config.list, can be used as an array 655 * index. It is invariant over the lifetime of the CRTC. 656 */ 657 unsigned index; 658 659 /* position of cursor plane on crtc */ 660 int cursor_x; 661 int cursor_y; 662 663 bool enabled; 664 665 /* Requested mode from modesetting. */ 666 struct drm_display_mode mode; 667 668 /* Programmed mode in hw, after adjustments for encoders, 669 * crtc, panel scaling etc. Needed for timestamping etc. 670 */ 671 struct drm_display_mode hwmode; 672 673 int x, y; 674 const struct drm_crtc_funcs *funcs; 675 676 /* Legacy FB CRTC gamma size for reporting to userspace */ 677 uint32_t gamma_size; 678 uint16_t *gamma_store; 679 680 /* if you are using the helper */ 681 const struct drm_crtc_helper_funcs *helper_private; 682 683 struct drm_object_properties properties; 684 685 /** 686 * @state: 687 * 688 * Current atomic state for this CRTC. 689 */ 690 struct drm_crtc_state *state; 691 692 /** 693 * @commit_list: 694 * 695 * List of &drm_crtc_commit structures tracking pending commits. 696 * Protected by @commit_lock. This list doesn't hold its own full 697 * reference, but burrows it from the ongoing commit. Commit entries 698 * must be removed from this list once the commit is fully completed, 699 * but before it's correspoding &drm_atomic_state gets destroyed. 700 */ 701 struct list_head commit_list; 702 703 /** 704 * @commit_lock: 705 * 706 * Spinlock to protect @commit_list. 707 */ 708 spinlock_t commit_lock; 709 710 /** 711 * @acquire_ctx: 712 * 713 * Per-CRTC implicit acquire context used by atomic drivers for legacy 714 * IOCTLs, so that atomic drivers can get at the locking acquire 715 * context. 716 */ 717 struct drm_modeset_acquire_ctx *acquire_ctx; 718 719 #ifdef CONFIG_DEBUG_FS 720 /** 721 * @debugfs_entry: 722 * 723 * Debugfs directory for this CRTC. 724 */ 725 struct dentry *debugfs_entry; 726 727 /** 728 * @crc: 729 * 730 * Configuration settings of CRC capture. 731 */ 732 struct drm_crtc_crc crc; 733 #endif 734 735 /** 736 * @fence_context: 737 * 738 * timeline context used for fence operations. 739 */ 740 unsigned int fence_context; 741 742 /** 743 * @fence_lock: 744 * 745 * spinlock to protect the fences in the fence_context. 746 */ 747 748 spinlock_t fence_lock; 749 /** 750 * @fence_seqno: 751 * 752 * Seqno variable used as monotonic counter for the fences 753 * created on the CRTC's timeline. 754 */ 755 unsigned long fence_seqno; 756 757 /** 758 * @timeline_name: 759 * 760 * The name of the CRTC's fence timeline. 761 */ 762 char timeline_name[32]; 763 }; 764 765 /** 766 * struct drm_mode_set - new values for a CRTC config change 767 * @fb: framebuffer to use for new config 768 * @crtc: CRTC whose configuration we're about to change 769 * @mode: mode timings to use 770 * @x: position of this CRTC relative to @fb 771 * @y: position of this CRTC relative to @fb 772 * @connectors: array of connectors to drive with this CRTC if possible 773 * @num_connectors: size of @connectors array 774 * 775 * Represents a single crtc the connectors that it drives with what mode 776 * and from which framebuffer it scans out from. 777 * 778 * This is used to set modes. 779 */ 780 struct drm_mode_set { 781 struct drm_framebuffer *fb; 782 struct drm_crtc *crtc; 783 struct drm_display_mode *mode; 784 785 uint32_t x; 786 uint32_t y; 787 788 struct drm_connector **connectors; 789 size_t num_connectors; 790 }; 791 792 #define obj_to_crtc(x) container_of(x, struct drm_crtc, base) 793 794 __printf(6, 7) 795 int drm_crtc_init_with_planes(struct drm_device *dev, 796 struct drm_crtc *crtc, 797 struct drm_plane *primary, 798 struct drm_plane *cursor, 799 const struct drm_crtc_funcs *funcs, 800 const char *name, ...); 801 void drm_crtc_cleanup(struct drm_crtc *crtc); 802 803 /** 804 * drm_crtc_index - find the index of a registered CRTC 805 * @crtc: CRTC to find index for 806 * 807 * Given a registered CRTC, return the index of that CRTC within a DRM 808 * device's list of CRTCs. 809 */ 810 static inline unsigned int drm_crtc_index(const struct drm_crtc *crtc) 811 { 812 return crtc->index; 813 } 814 815 /** 816 * drm_crtc_mask - find the mask of a registered CRTC 817 * @crtc: CRTC to find mask for 818 * 819 * Given a registered CRTC, return the mask bit of that CRTC for an 820 * encoder's possible_crtcs field. 821 */ 822 static inline uint32_t drm_crtc_mask(const struct drm_crtc *crtc) 823 { 824 return 1 << drm_crtc_index(crtc); 825 } 826 827 void drm_crtc_get_hv_timing(const struct drm_display_mode *mode, 828 int *hdisplay, int *vdisplay); 829 int drm_crtc_force_disable(struct drm_crtc *crtc); 830 int drm_crtc_force_disable_all(struct drm_device *dev); 831 832 int drm_mode_set_config_internal(struct drm_mode_set *set); 833 834 /* Helpers */ 835 static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev, 836 uint32_t id) 837 { 838 struct drm_mode_object *mo; 839 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CRTC); 840 return mo ? obj_to_crtc(mo) : NULL; 841 } 842 843 #define drm_for_each_crtc(crtc, dev) \ 844 list_for_each_entry(crtc, &(dev)->mode_config.crtc_list, head) 845 846 static inline void 847 assert_drm_connector_list_read_locked(struct drm_mode_config *mode_config) 848 { 849 /* 850 * The connector hotadd/remove code currently grabs both locks when 851 * updating lists. Hence readers need only hold either of them to be 852 * safe and the check amounts to 853 * 854 * WARN_ON(not_holding(A) && not_holding(B)). 855 */ 856 WARN_ON(!mutex_is_locked(&mode_config->mutex) && 857 !drm_modeset_is_locked(&mode_config->connection_mutex)); 858 } 859 860 #endif /* __DRM_CRTC_H__ */ 861