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