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_device.h> 43 #include <drm/drm_property.h> 44 #include <drm/drm_edid.h> 45 #include <drm/drm_plane.h> 46 #include <drm/drm_blend.h> 47 #include <drm/drm_color_mgmt.h> 48 #include <drm/drm_debugfs_crc.h> 49 #include <drm/drm_mode_config.h> 50 51 struct drm_device; 52 struct drm_mode_set; 53 struct drm_file; 54 struct drm_clip_rect; 55 struct drm_printer; 56 struct drm_self_refresh_data; 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_pending_vblank_event; 72 struct drm_plane; 73 struct drm_bridge; 74 struct drm_atomic_state; 75 76 struct drm_crtc_helper_funcs; 77 struct drm_plane_helper_funcs; 78 79 /** 80 * struct drm_crtc_state - mutable CRTC state 81 * 82 * Note that the distinction between @enable and @active is rather subtle: 83 * Flipping @active while @enable is set without changing anything else may 84 * never return in a failure from the &drm_mode_config_funcs.atomic_check 85 * callback. Userspace assumes that a DPMS On will always succeed. In other 86 * words: @enable controls resource assignment, @active controls the actual 87 * hardware state. 88 * 89 * The three booleans active_changed, connectors_changed and mode_changed are 90 * intended to indicate whether a full modeset is needed, rather than strictly 91 * describing what has changed in a commit. See also: 92 * drm_atomic_crtc_needs_modeset() 93 * 94 * WARNING: Transitional helpers (like drm_helper_crtc_mode_set() or 95 * drm_helper_crtc_mode_set_base()) do not maintain many of the derived control 96 * state like @plane_mask so drivers not converted over to atomic helpers should 97 * not rely on these being accurate! 98 */ 99 struct drm_crtc_state { 100 /** @crtc: backpointer to the CRTC */ 101 struct drm_crtc *crtc; 102 103 /** 104 * @enable: Whether the CRTC should be enabled, gates all other state. 105 * This controls reservations of shared resources. Actual hardware state 106 * is controlled by @active. 107 */ 108 bool enable; 109 110 /** 111 * @active: Whether the CRTC is actively displaying (used for DPMS). 112 * Implies that @enable is set. The driver must not release any shared 113 * resources if @active is set to false but @enable still true, because 114 * userspace expects that a DPMS ON always succeeds. 115 * 116 * Hence drivers must not consult @active in their various 117 * &drm_mode_config_funcs.atomic_check callback to reject an atomic 118 * commit. They can consult it to aid in the computation of derived 119 * hardware state, since even in the DPMS OFF state the display hardware 120 * should be as much powered down as when the CRTC is completely 121 * disabled through setting @enable to false. 122 */ 123 bool active; 124 125 /** 126 * @planes_changed: Planes on this crtc are updated. Used by the atomic 127 * helpers and drivers to steer the atomic commit control flow. 128 */ 129 bool planes_changed : 1; 130 131 /** 132 * @mode_changed: @mode or @enable has been changed. Used by the atomic 133 * helpers and drivers to steer the atomic commit control flow. See also 134 * drm_atomic_crtc_needs_modeset(). 135 * 136 * Drivers are supposed to set this for any CRTC state changes that 137 * require a full modeset. They can also reset it to false if e.g. a 138 * @mode change can be done without a full modeset by only changing 139 * scaler settings. 140 */ 141 bool mode_changed : 1; 142 143 /** 144 * @active_changed: @active has been toggled. Used by the atomic 145 * helpers and drivers to steer the atomic commit control flow. See also 146 * drm_atomic_crtc_needs_modeset(). 147 */ 148 bool active_changed : 1; 149 150 /** 151 * @connectors_changed: Connectors to this crtc have been updated, 152 * either in their state or routing. Used by the atomic 153 * helpers and drivers to steer the atomic commit control flow. See also 154 * drm_atomic_crtc_needs_modeset(). 155 * 156 * Drivers are supposed to set this as-needed from their own atomic 157 * check code, e.g. from &drm_encoder_helper_funcs.atomic_check 158 */ 159 bool connectors_changed : 1; 160 /** 161 * @zpos_changed: zpos values of planes on this crtc have been updated. 162 * Used by the atomic helpers and drivers to steer the atomic commit 163 * control flow. 164 */ 165 bool zpos_changed : 1; 166 /** 167 * @color_mgmt_changed: Color management properties have changed 168 * (@gamma_lut, @degamma_lut or @ctm). Used by the atomic helpers and 169 * drivers to steer the atomic commit control flow. 170 */ 171 bool color_mgmt_changed : 1; 172 173 /** 174 * @no_vblank: 175 * 176 * Reflects the ability of a CRTC to send VBLANK events. This state 177 * usually depends on the pipeline configuration. If set to true, DRM 178 * atomic helpers will send out a fake VBLANK event during display 179 * updates after all hardware changes have been committed. This is 180 * implemented in drm_atomic_helper_fake_vblank(). 181 * 182 * One usage is for drivers and/or hardware without support for VBLANK 183 * interrupts. Such drivers typically do not initialize vblanking 184 * (i.e., call drm_vblank_init() with the number of CRTCs). For CRTCs 185 * without initialized vblanking, this field is set to true in 186 * drm_atomic_helper_check_modeset(), and a fake VBLANK event will be 187 * send out on each update of the display pipeline by 188 * drm_atomic_helper_fake_vblank(). 189 * 190 * Another usage is CRTCs feeding a writeback connector operating in 191 * oneshot mode. In this case the fake VBLANK event is only generated 192 * when a job is queued to the writeback connector, and we want the 193 * core to fake VBLANK events when this part of the pipeline hasn't 194 * changed but others had or when the CRTC and connectors are being 195 * disabled. 196 * 197 * __drm_atomic_helper_crtc_duplicate_state() will not reset the value 198 * from the current state, the CRTC driver is then responsible for 199 * updating this field when needed. 200 * 201 * Note that the combination of &drm_crtc_state.event == NULL and 202 * &drm_crtc_state.no_blank == true is valid and usually used when the 203 * writeback connector attached to the CRTC has a new job queued. In 204 * this case the driver will send the VBLANK event on its own when the 205 * writeback job is complete. 206 */ 207 bool no_vblank : 1; 208 209 /** 210 * @plane_mask: Bitmask of drm_plane_mask(plane) of planes attached to 211 * this CRTC. 212 */ 213 u32 plane_mask; 214 215 /** 216 * @connector_mask: Bitmask of drm_connector_mask(connector) of 217 * connectors attached to this CRTC. 218 */ 219 u32 connector_mask; 220 221 /** 222 * @encoder_mask: Bitmask of drm_encoder_mask(encoder) of encoders 223 * attached to this CRTC. 224 */ 225 u32 encoder_mask; 226 227 /** 228 * @adjusted_mode: 229 * 230 * Internal display timings which can be used by the driver to handle 231 * differences between the mode requested by userspace in @mode and what 232 * is actually programmed into the hardware. 233 * 234 * For drivers using &drm_bridge, this stores hardware display timings 235 * used between the CRTC and the first bridge. For other drivers, the 236 * meaning of the adjusted_mode field is purely driver implementation 237 * defined information, and will usually be used to store the hardware 238 * display timings used between the CRTC and encoder blocks. 239 */ 240 struct drm_display_mode adjusted_mode; 241 242 /** 243 * @mode: 244 * 245 * Display timings requested by userspace. The driver should try to 246 * match the refresh rate as close as possible (but note that it's 247 * undefined what exactly is close enough, e.g. some of the HDMI modes 248 * only differ in less than 1% of the refresh rate). The active width 249 * and height as observed by userspace for positioning planes must match 250 * exactly. 251 * 252 * For external connectors where the sink isn't fixed (like with a 253 * built-in panel), this mode here should match the physical mode on the 254 * wire to the last details (i.e. including sync polarities and 255 * everything). 256 */ 257 struct drm_display_mode mode; 258 259 /** 260 * @mode_blob: &drm_property_blob for @mode, for exposing the mode to 261 * atomic userspace. 262 */ 263 struct drm_property_blob *mode_blob; 264 265 /** 266 * @degamma_lut: 267 * 268 * Lookup table for converting framebuffer pixel data before apply the 269 * color conversion matrix @ctm. See drm_crtc_enable_color_mgmt(). The 270 * blob (if not NULL) is an array of &struct drm_color_lut. 271 */ 272 struct drm_property_blob *degamma_lut; 273 274 /** 275 * @ctm: 276 * 277 * Color transformation matrix. See drm_crtc_enable_color_mgmt(). The 278 * blob (if not NULL) is a &struct drm_color_ctm. 279 */ 280 struct drm_property_blob *ctm; 281 282 /** 283 * @gamma_lut: 284 * 285 * Lookup table for converting pixel data after the color conversion 286 * matrix @ctm. See drm_crtc_enable_color_mgmt(). The blob (if not 287 * NULL) is an array of &struct drm_color_lut. 288 * 289 * Note that for mostly historical reasons stemming from Xorg heritage, 290 * this is also used to store the color map (also sometimes color lut, 291 * CLUT or color palette) for indexed formats like DRM_FORMAT_C8. 292 */ 293 struct drm_property_blob *gamma_lut; 294 295 /** 296 * @target_vblank: 297 * 298 * Target vertical blank period when a page flip 299 * should take effect. 300 */ 301 u32 target_vblank; 302 303 /** 304 * @async_flip: 305 * 306 * This is set when DRM_MODE_PAGE_FLIP_ASYNC is set in the legacy 307 * PAGE_FLIP IOCTL. It's not wired up for the atomic IOCTL itself yet. 308 */ 309 bool async_flip; 310 311 /** 312 * @vrr_enabled: 313 * 314 * Indicates if variable refresh rate should be enabled for the CRTC. 315 * Support for the requested vrr state will depend on driver and 316 * hardware capabiltiy - lacking support is not treated as failure. 317 */ 318 bool vrr_enabled; 319 320 /** 321 * @self_refresh_active: 322 * 323 * Used by the self refresh helpers to denote when a self refresh 324 * transition is occurring. This will be set on enable/disable callbacks 325 * when self refresh is being enabled or disabled. In some cases, it may 326 * not be desirable to fully shut off the crtc during self refresh. 327 * CRTC's can inspect this flag and determine the best course of action. 328 */ 329 bool self_refresh_active; 330 331 /** 332 * @scaling_filter: 333 * 334 * Scaling filter to be applied 335 */ 336 enum drm_scaling_filter scaling_filter; 337 338 /** 339 * @event: 340 * 341 * Optional pointer to a DRM event to signal upon completion of the 342 * state update. The driver must send out the event when the atomic 343 * commit operation completes. There are two cases: 344 * 345 * - The event is for a CRTC which is being disabled through this 346 * atomic commit. In that case the event can be send out any time 347 * after the hardware has stopped scanning out the current 348 * framebuffers. It should contain the timestamp and counter for the 349 * last vblank before the display pipeline was shut off. The simplest 350 * way to achieve that is calling drm_crtc_send_vblank_event() 351 * somewhen after drm_crtc_vblank_off() has been called. 352 * 353 * - For a CRTC which is enabled at the end of the commit (even when it 354 * undergoes an full modeset) the vblank timestamp and counter must 355 * be for the vblank right before the first frame that scans out the 356 * new set of buffers. Again the event can only be sent out after the 357 * hardware has stopped scanning out the old buffers. 358 * 359 * - Events for disabled CRTCs are not allowed, and drivers can ignore 360 * that case. 361 * 362 * For very simple hardware without VBLANK interrupt, enabling 363 * &struct drm_crtc_state.no_vblank makes DRM's atomic commit helpers 364 * send a fake VBLANK event at the end of the display update after all 365 * hardware changes have been applied. See 366 * drm_atomic_helper_fake_vblank(). 367 * 368 * For more complex hardware this 369 * can be handled by the drm_crtc_send_vblank_event() function, 370 * which the driver should call on the provided event upon completion of 371 * the atomic commit. Note that if the driver supports vblank signalling 372 * and timestamping the vblank counters and timestamps must agree with 373 * the ones returned from page flip events. With the current vblank 374 * helper infrastructure this can be achieved by holding a vblank 375 * reference while the page flip is pending, acquired through 376 * drm_crtc_vblank_get() and released with drm_crtc_vblank_put(). 377 * Drivers are free to implement their own vblank counter and timestamp 378 * tracking though, e.g. if they have accurate timestamp registers in 379 * hardware. 380 * 381 * For hardware which supports some means to synchronize vblank 382 * interrupt delivery with committing display state there's also 383 * drm_crtc_arm_vblank_event(). See the documentation of that function 384 * for a detailed discussion of the constraints it needs to be used 385 * safely. 386 * 387 * If the device can't notify of flip completion in a race-free way 388 * at all, then the event should be armed just after the page flip is 389 * committed. In the worst case the driver will send the event to 390 * userspace one frame too late. This doesn't allow for a real atomic 391 * update, but it should avoid tearing. 392 */ 393 struct drm_pending_vblank_event *event; 394 395 /** 396 * @commit: 397 * 398 * This tracks how the commit for this update proceeds through the 399 * various phases. This is never cleared, except when we destroy the 400 * state, so that subsequent commits can synchronize with previous ones. 401 */ 402 struct drm_crtc_commit *commit; 403 404 /** @state: backpointer to global drm_atomic_state */ 405 struct drm_atomic_state *state; 406 }; 407 408 /** 409 * struct drm_crtc_funcs - control CRTCs for a given device 410 * 411 * The drm_crtc_funcs structure is the central CRTC management structure 412 * in the DRM. Each CRTC controls one or more connectors (note that the name 413 * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc. 414 * connectors, not just CRTs). 415 * 416 * Each driver is responsible for filling out this structure at startup time, 417 * in addition to providing other modesetting features, like i2c and DDC 418 * bus accessors. 419 */ 420 struct drm_crtc_funcs { 421 /** 422 * @reset: 423 * 424 * Reset CRTC hardware and software state to off. This function isn't 425 * called by the core directly, only through drm_mode_config_reset(). 426 * It's not a helper hook only for historical reasons. 427 * 428 * Atomic drivers can use drm_atomic_helper_crtc_reset() to reset 429 * atomic state using this hook. 430 */ 431 void (*reset)(struct drm_crtc *crtc); 432 433 /** 434 * @cursor_set: 435 * 436 * Update the cursor image. The cursor position is relative to the CRTC 437 * and can be partially or fully outside of the visible area. 438 * 439 * Note that contrary to all other KMS functions the legacy cursor entry 440 * points don't take a framebuffer object, but instead take directly a 441 * raw buffer object id from the driver's buffer manager (which is 442 * either GEM or TTM for current drivers). 443 * 444 * This entry point is deprecated, drivers should instead implement 445 * universal plane support and register a proper cursor plane using 446 * drm_crtc_init_with_planes(). 447 * 448 * This callback is optional 449 * 450 * RETURNS: 451 * 452 * 0 on success or a negative error code on failure. 453 */ 454 int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv, 455 uint32_t handle, uint32_t width, uint32_t height); 456 457 /** 458 * @cursor_set2: 459 * 460 * Update the cursor image, including hotspot information. The hotspot 461 * must not affect the cursor position in CRTC coordinates, but is only 462 * meant as a hint for virtualized display hardware to coordinate the 463 * guests and hosts cursor position. The cursor hotspot is relative to 464 * the cursor image. Otherwise this works exactly like @cursor_set. 465 * 466 * This entry point is deprecated, drivers should instead implement 467 * universal plane support and register a proper cursor plane using 468 * drm_crtc_init_with_planes(). 469 * 470 * This callback is optional. 471 * 472 * RETURNS: 473 * 474 * 0 on success or a negative error code on failure. 475 */ 476 int (*cursor_set2)(struct drm_crtc *crtc, struct drm_file *file_priv, 477 uint32_t handle, uint32_t width, uint32_t height, 478 int32_t hot_x, int32_t hot_y); 479 480 /** 481 * @cursor_move: 482 * 483 * Update the cursor position. The cursor does not need to be visible 484 * when this hook is called. 485 * 486 * This entry point is deprecated, drivers should instead implement 487 * universal plane support and register a proper cursor plane using 488 * drm_crtc_init_with_planes(). 489 * 490 * This callback is optional. 491 * 492 * RETURNS: 493 * 494 * 0 on success or a negative error code on failure. 495 */ 496 int (*cursor_move)(struct drm_crtc *crtc, int x, int y); 497 498 /** 499 * @gamma_set: 500 * 501 * Set gamma on the CRTC. 502 * 503 * This callback is optional. 504 * 505 * Atomic drivers who want to support gamma tables should implement the 506 * atomic color management support, enabled by calling 507 * drm_crtc_enable_color_mgmt(), which then supports the legacy gamma 508 * interface through the drm_atomic_helper_legacy_gamma_set() 509 * compatibility implementation. 510 */ 511 int (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b, 512 uint32_t size, 513 struct drm_modeset_acquire_ctx *ctx); 514 515 /** 516 * @destroy: 517 * 518 * Clean up CRTC resources. This is only called at driver unload time 519 * through drm_mode_config_cleanup() since a CRTC cannot be hotplugged 520 * in DRM. 521 */ 522 void (*destroy)(struct drm_crtc *crtc); 523 524 /** 525 * @set_config: 526 * 527 * This is the main legacy entry point to change the modeset state on a 528 * CRTC. All the details of the desired configuration are passed in a 529 * &struct drm_mode_set - see there for details. 530 * 531 * Drivers implementing atomic modeset should use 532 * drm_atomic_helper_set_config() to implement this hook. 533 * 534 * RETURNS: 535 * 536 * 0 on success or a negative error code on failure. 537 */ 538 int (*set_config)(struct drm_mode_set *set, 539 struct drm_modeset_acquire_ctx *ctx); 540 541 /** 542 * @page_flip: 543 * 544 * Legacy entry point to schedule a flip to the given framebuffer. 545 * 546 * Page flipping is a synchronization mechanism that replaces the frame 547 * buffer being scanned out by the CRTC with a new frame buffer during 548 * vertical blanking, avoiding tearing (except when requested otherwise 549 * through the DRM_MODE_PAGE_FLIP_ASYNC flag). When an application 550 * requests a page flip the DRM core verifies that the new frame buffer 551 * is large enough to be scanned out by the CRTC in the currently 552 * configured mode and then calls this hook with a pointer to the new 553 * frame buffer. 554 * 555 * The driver must wait for any pending rendering to the new framebuffer 556 * to complete before executing the flip. It should also wait for any 557 * pending rendering from other drivers if the underlying buffer is a 558 * shared dma-buf. 559 * 560 * An application can request to be notified when the page flip has 561 * completed. The drm core will supply a &struct drm_event in the event 562 * parameter in this case. This can be handled by the 563 * drm_crtc_send_vblank_event() function, which the driver should call on 564 * the provided event upon completion of the flip. Note that if 565 * the driver supports vblank signalling and timestamping the vblank 566 * counters and timestamps must agree with the ones returned from page 567 * flip events. With the current vblank helper infrastructure this can 568 * be achieved by holding a vblank reference while the page flip is 569 * pending, acquired through drm_crtc_vblank_get() and released with 570 * drm_crtc_vblank_put(). Drivers are free to implement their own vblank 571 * counter and timestamp tracking though, e.g. if they have accurate 572 * timestamp registers in hardware. 573 * 574 * This callback is optional. 575 * 576 * NOTE: 577 * 578 * Very early versions of the KMS ABI mandated that the driver must 579 * block (but not reject) any rendering to the old framebuffer until the 580 * flip operation has completed and the old framebuffer is no longer 581 * visible. This requirement has been lifted, and userspace is instead 582 * expected to request delivery of an event and wait with recycling old 583 * buffers until such has been received. 584 * 585 * RETURNS: 586 * 587 * 0 on success or a negative error code on failure. Note that if a 588 * page flip operation is already pending the callback should return 589 * -EBUSY. Pageflips on a disabled CRTC (either by setting a NULL mode 590 * or just runtime disabled through DPMS respectively the new atomic 591 * "ACTIVE" state) should result in an -EINVAL error code. Note that 592 * drm_atomic_helper_page_flip() checks this already for atomic drivers. 593 */ 594 int (*page_flip)(struct drm_crtc *crtc, 595 struct drm_framebuffer *fb, 596 struct drm_pending_vblank_event *event, 597 uint32_t flags, 598 struct drm_modeset_acquire_ctx *ctx); 599 600 /** 601 * @page_flip_target: 602 * 603 * Same as @page_flip but with an additional parameter specifying the 604 * absolute target vertical blank period (as reported by 605 * drm_crtc_vblank_count()) when the flip should take effect. 606 * 607 * Note that the core code calls drm_crtc_vblank_get before this entry 608 * point, and will call drm_crtc_vblank_put if this entry point returns 609 * any non-0 error code. It's the driver's responsibility to call 610 * drm_crtc_vblank_put after this entry point returns 0, typically when 611 * the flip completes. 612 */ 613 int (*page_flip_target)(struct drm_crtc *crtc, 614 struct drm_framebuffer *fb, 615 struct drm_pending_vblank_event *event, 616 uint32_t flags, uint32_t target, 617 struct drm_modeset_acquire_ctx *ctx); 618 619 /** 620 * @set_property: 621 * 622 * This is the legacy entry point to update a property attached to the 623 * CRTC. 624 * 625 * This callback is optional if the driver does not support any legacy 626 * driver-private properties. For atomic drivers it is not used because 627 * property handling is done entirely in the DRM core. 628 * 629 * RETURNS: 630 * 631 * 0 on success or a negative error code on failure. 632 */ 633 int (*set_property)(struct drm_crtc *crtc, 634 struct drm_property *property, uint64_t val); 635 636 /** 637 * @atomic_duplicate_state: 638 * 639 * Duplicate the current atomic state for this CRTC and return it. 640 * The core and helpers guarantee that any atomic state duplicated with 641 * this hook and still owned by the caller (i.e. not transferred to the 642 * driver by calling &drm_mode_config_funcs.atomic_commit) will be 643 * cleaned up by calling the @atomic_destroy_state hook in this 644 * structure. 645 * 646 * This callback is mandatory for atomic drivers. 647 * 648 * Atomic drivers which don't subclass &struct drm_crtc_state should use 649 * drm_atomic_helper_crtc_duplicate_state(). Drivers that subclass the 650 * state structure to extend it with driver-private state should use 651 * __drm_atomic_helper_crtc_duplicate_state() to make sure shared state is 652 * duplicated in a consistent fashion across drivers. 653 * 654 * It is an error to call this hook before &drm_crtc.state has been 655 * initialized correctly. 656 * 657 * NOTE: 658 * 659 * If the duplicate state references refcounted resources this hook must 660 * acquire a reference for each of them. The driver must release these 661 * references again in @atomic_destroy_state. 662 * 663 * RETURNS: 664 * 665 * Duplicated atomic state or NULL when the allocation failed. 666 */ 667 struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc); 668 669 /** 670 * @atomic_destroy_state: 671 * 672 * Destroy a state duplicated with @atomic_duplicate_state and release 673 * or unreference all resources it references 674 * 675 * This callback is mandatory for atomic drivers. 676 */ 677 void (*atomic_destroy_state)(struct drm_crtc *crtc, 678 struct drm_crtc_state *state); 679 680 /** 681 * @atomic_set_property: 682 * 683 * Decode a driver-private property value and store the decoded value 684 * into the passed-in state structure. Since the atomic core decodes all 685 * standardized properties (even for extensions beyond the core set of 686 * properties which might not be implemented by all drivers) this 687 * requires drivers to subclass the state structure. 688 * 689 * Such driver-private properties should really only be implemented for 690 * truly hardware/vendor specific state. Instead it is preferred to 691 * standardize atomic extension and decode the properties used to expose 692 * such an extension in the core. 693 * 694 * Do not call this function directly, use 695 * drm_atomic_crtc_set_property() instead. 696 * 697 * This callback is optional if the driver does not support any 698 * driver-private atomic properties. 699 * 700 * NOTE: 701 * 702 * This function is called in the state assembly phase of atomic 703 * modesets, which can be aborted for any reason (including on 704 * userspace's request to just check whether a configuration would be 705 * possible). Drivers MUST NOT touch any persistent state (hardware or 706 * software) or data structures except the passed in @state parameter. 707 * 708 * Also since userspace controls in which order properties are set this 709 * function must not do any input validation (since the state update is 710 * incomplete and hence likely inconsistent). Instead any such input 711 * validation must be done in the various atomic_check callbacks. 712 * 713 * RETURNS: 714 * 715 * 0 if the property has been found, -EINVAL if the property isn't 716 * implemented by the driver (which should never happen, the core only 717 * asks for properties attached to this CRTC). No other validation is 718 * allowed by the driver. The core already checks that the property 719 * value is within the range (integer, valid enum value, ...) the driver 720 * set when registering the property. 721 */ 722 int (*atomic_set_property)(struct drm_crtc *crtc, 723 struct drm_crtc_state *state, 724 struct drm_property *property, 725 uint64_t val); 726 /** 727 * @atomic_get_property: 728 * 729 * Reads out the decoded driver-private property. This is used to 730 * implement the GETCRTC IOCTL. 731 * 732 * Do not call this function directly, use 733 * drm_atomic_crtc_get_property() instead. 734 * 735 * This callback is optional if the driver does not support any 736 * driver-private atomic properties. 737 * 738 * RETURNS: 739 * 740 * 0 on success, -EINVAL if the property isn't implemented by the 741 * driver (which should never happen, the core only asks for 742 * properties attached to this CRTC). 743 */ 744 int (*atomic_get_property)(struct drm_crtc *crtc, 745 const struct drm_crtc_state *state, 746 struct drm_property *property, 747 uint64_t *val); 748 749 /** 750 * @late_register: 751 * 752 * This optional hook can be used to register additional userspace 753 * interfaces attached to the crtc like debugfs interfaces. 754 * It is called late in the driver load sequence from drm_dev_register(). 755 * Everything added from this callback should be unregistered in 756 * the early_unregister callback. 757 * 758 * Returns: 759 * 760 * 0 on success, or a negative error code on failure. 761 */ 762 int (*late_register)(struct drm_crtc *crtc); 763 764 /** 765 * @early_unregister: 766 * 767 * This optional hook should be used to unregister the additional 768 * userspace interfaces attached to the crtc from 769 * @late_register. It is called from drm_dev_unregister(), 770 * early in the driver unload sequence to disable userspace access 771 * before data structures are torndown. 772 */ 773 void (*early_unregister)(struct drm_crtc *crtc); 774 775 /** 776 * @set_crc_source: 777 * 778 * Changes the source of CRC checksums of frames at the request of 779 * userspace, typically for testing purposes. The sources available are 780 * specific of each driver and a %NULL value indicates that CRC 781 * generation is to be switched off. 782 * 783 * When CRC generation is enabled, the driver should call 784 * drm_crtc_add_crc_entry() at each frame, providing any information 785 * that characterizes the frame contents in the crcN arguments, as 786 * provided from the configured source. Drivers must accept an "auto" 787 * source name that will select a default source for this CRTC. 788 * 789 * This may trigger an atomic modeset commit if necessary, to enable CRC 790 * generation. 791 * 792 * Note that "auto" can depend upon the current modeset configuration, 793 * e.g. it could pick an encoder or output specific CRC sampling point. 794 * 795 * This callback is optional if the driver does not support any CRC 796 * generation functionality. 797 * 798 * RETURNS: 799 * 800 * 0 on success or a negative error code on failure. 801 */ 802 int (*set_crc_source)(struct drm_crtc *crtc, const char *source); 803 804 /** 805 * @verify_crc_source: 806 * 807 * verifies the source of CRC checksums of frames before setting the 808 * source for CRC and during crc open. Source parameter can be NULL 809 * while disabling crc source. 810 * 811 * This callback is optional if the driver does not support any CRC 812 * generation functionality. 813 * 814 * RETURNS: 815 * 816 * 0 on success or a negative error code on failure. 817 */ 818 int (*verify_crc_source)(struct drm_crtc *crtc, const char *source, 819 size_t *values_cnt); 820 /** 821 * @get_crc_sources: 822 * 823 * Driver callback for getting a list of all the available sources for 824 * CRC generation. This callback depends upon verify_crc_source, So 825 * verify_crc_source callback should be implemented before implementing 826 * this. Driver can pass full list of available crc sources, this 827 * callback does the verification on each crc-source before passing it 828 * to userspace. 829 * 830 * This callback is optional if the driver does not support exporting of 831 * possible CRC sources list. 832 * 833 * RETURNS: 834 * 835 * a constant character pointer to the list of all the available CRC 836 * sources. On failure driver should return NULL. count should be 837 * updated with number of sources in list. if zero we don't process any 838 * source from the list. 839 */ 840 const char *const *(*get_crc_sources)(struct drm_crtc *crtc, 841 size_t *count); 842 843 /** 844 * @atomic_print_state: 845 * 846 * If driver subclasses &struct drm_crtc_state, it should implement 847 * this optional hook for printing additional driver specific state. 848 * 849 * Do not call this directly, use drm_atomic_crtc_print_state() 850 * instead. 851 */ 852 void (*atomic_print_state)(struct drm_printer *p, 853 const struct drm_crtc_state *state); 854 855 /** 856 * @get_vblank_counter: 857 * 858 * Driver callback for fetching a raw hardware vblank counter for the 859 * CRTC. It's meant to be used by new drivers as the replacement of 860 * &drm_driver.get_vblank_counter hook. 861 * 862 * This callback is optional. If a device doesn't have a hardware 863 * counter, the driver can simply leave the hook as NULL. The DRM core 864 * will account for missed vblank events while interrupts where disabled 865 * based on system timestamps. 866 * 867 * Wraparound handling and loss of events due to modesetting is dealt 868 * with in the DRM core code, as long as drivers call 869 * drm_crtc_vblank_off() and drm_crtc_vblank_on() when disabling or 870 * enabling a CRTC. 871 * 872 * See also &drm_device.vblank_disable_immediate and 873 * &drm_device.max_vblank_count. 874 * 875 * Returns: 876 * 877 * Raw vblank counter value. 878 */ 879 u32 (*get_vblank_counter)(struct drm_crtc *crtc); 880 881 /** 882 * @enable_vblank: 883 * 884 * Enable vblank interrupts for the CRTC. It's meant to be used by 885 * new drivers as the replacement of &drm_driver.enable_vblank hook. 886 * 887 * Returns: 888 * 889 * Zero on success, appropriate errno if the vblank interrupt cannot 890 * be enabled. 891 */ 892 int (*enable_vblank)(struct drm_crtc *crtc); 893 894 /** 895 * @disable_vblank: 896 * 897 * Disable vblank interrupts for the CRTC. It's meant to be used by 898 * new drivers as the replacement of &drm_driver.disable_vblank hook. 899 */ 900 void (*disable_vblank)(struct drm_crtc *crtc); 901 902 /** 903 * @get_vblank_timestamp: 904 * 905 * Called by drm_get_last_vbltimestamp(). Should return a precise 906 * timestamp when the most recent vblank interval ended or will end. 907 * 908 * Specifically, the timestamp in @vblank_time should correspond as 909 * closely as possible to the time when the first video scanline of 910 * the video frame after the end of vblank will start scanning out, 911 * the time immediately after end of the vblank interval. If the 912 * @crtc is currently inside vblank, this will be a time in the future. 913 * If the @crtc is currently scanning out a frame, this will be the 914 * past start time of the current scanout. This is meant to adhere 915 * to the OpenML OML_sync_control extension specification. 916 * 917 * Parameters: 918 * 919 * crtc: 920 * CRTC for which timestamp should be returned. 921 * max_error: 922 * Maximum allowable timestamp error in nanoseconds. 923 * Implementation should strive to provide timestamp 924 * with an error of at most max_error nanoseconds. 925 * Returns true upper bound on error for timestamp. 926 * vblank_time: 927 * Target location for returned vblank timestamp. 928 * in_vblank_irq: 929 * True when called from drm_crtc_handle_vblank(). Some drivers 930 * need to apply some workarounds for gpu-specific vblank irq quirks 931 * if flag is set. 932 * 933 * Returns: 934 * 935 * True on success, false on failure, which means the core should 936 * fallback to a simple timestamp taken in drm_crtc_handle_vblank(). 937 */ 938 bool (*get_vblank_timestamp)(struct drm_crtc *crtc, 939 int *max_error, 940 ktime_t *vblank_time, 941 bool in_vblank_irq); 942 }; 943 944 /** 945 * struct drm_crtc - central CRTC control structure 946 * 947 * Each CRTC may have one or more connectors associated with it. This structure 948 * allows the CRTC to be controlled. 949 */ 950 struct drm_crtc { 951 /** @dev: parent DRM device */ 952 struct drm_device *dev; 953 /** @port: OF node used by drm_of_find_possible_crtcs(). */ 954 struct device_node *port; 955 /** 956 * @head: 957 * 958 * List of all CRTCs on @dev, linked from &drm_mode_config.crtc_list. 959 * Invariant over the lifetime of @dev and therefore does not need 960 * locking. 961 */ 962 struct list_head head; 963 964 /** @name: human readable name, can be overwritten by the driver */ 965 char *name; 966 967 /** 968 * @mutex: 969 * 970 * This provides a read lock for the overall CRTC state (mode, dpms 971 * state, ...) and a write lock for everything which can be update 972 * without a full modeset (fb, cursor data, CRTC properties ...). A full 973 * modeset also need to grab &drm_mode_config.connection_mutex. 974 * 975 * For atomic drivers specifically this protects @state. 976 */ 977 struct drm_modeset_lock mutex; 978 979 /** @base: base KMS object for ID tracking etc. */ 980 struct drm_mode_object base; 981 982 /** 983 * @primary: 984 * Primary plane for this CRTC. Note that this is only 985 * relevant for legacy IOCTL, it specifies the plane implicitly used by 986 * the SETCRTC and PAGE_FLIP IOCTLs. It does not have any significance 987 * beyond that. 988 */ 989 struct drm_plane *primary; 990 991 /** 992 * @cursor: 993 * Cursor plane for this CRTC. Note that this is only relevant for 994 * legacy IOCTL, it specifies the plane implicitly used by the SETCURSOR 995 * and SETCURSOR2 IOCTLs. It does not have any significance 996 * beyond that. 997 */ 998 struct drm_plane *cursor; 999 1000 /** 1001 * @index: Position inside the mode_config.list, can be used as an array 1002 * index. It is invariant over the lifetime of the CRTC. 1003 */ 1004 unsigned index; 1005 1006 /** 1007 * @cursor_x: Current x position of the cursor, used for universal 1008 * cursor planes because the SETCURSOR IOCTL only can update the 1009 * framebuffer without supplying the coordinates. Drivers should not use 1010 * this directly, atomic drivers should look at &drm_plane_state.crtc_x 1011 * of the cursor plane instead. 1012 */ 1013 int cursor_x; 1014 /** 1015 * @cursor_y: Current y position of the cursor, used for universal 1016 * cursor planes because the SETCURSOR IOCTL only can update the 1017 * framebuffer without supplying the coordinates. Drivers should not use 1018 * this directly, atomic drivers should look at &drm_plane_state.crtc_y 1019 * of the cursor plane instead. 1020 */ 1021 int cursor_y; 1022 1023 /** 1024 * @enabled: 1025 * 1026 * Is this CRTC enabled? Should only be used by legacy drivers, atomic 1027 * drivers should instead consult &drm_crtc_state.enable and 1028 * &drm_crtc_state.active. Atomic drivers can update this by calling 1029 * drm_atomic_helper_update_legacy_modeset_state(). 1030 */ 1031 bool enabled; 1032 1033 /** 1034 * @mode: 1035 * 1036 * Current mode timings. Should only be used by legacy drivers, atomic 1037 * drivers should instead consult &drm_crtc_state.mode. Atomic drivers 1038 * can update this by calling 1039 * drm_atomic_helper_update_legacy_modeset_state(). 1040 */ 1041 struct drm_display_mode mode; 1042 1043 /** 1044 * @hwmode: 1045 * 1046 * Programmed mode in hw, after adjustments for encoders, crtc, panel 1047 * scaling etc. Should only be used by legacy drivers, for high 1048 * precision vblank timestamps in 1049 * drm_crtc_vblank_helper_get_vblank_timestamp(). 1050 * 1051 * Note that atomic drivers should not use this, but instead use 1052 * &drm_crtc_state.adjusted_mode. And for high-precision timestamps 1053 * drm_crtc_vblank_helper_get_vblank_timestamp() used 1054 * &drm_vblank_crtc.hwmode, 1055 * which is filled out by calling drm_calc_timestamping_constants(). 1056 */ 1057 struct drm_display_mode hwmode; 1058 1059 /** 1060 * @x: 1061 * x position on screen. Should only be used by legacy drivers, atomic 1062 * drivers should look at &drm_plane_state.crtc_x of the primary plane 1063 * instead. Updated by calling 1064 * drm_atomic_helper_update_legacy_modeset_state(). 1065 */ 1066 int x; 1067 /** 1068 * @y: 1069 * y position on screen. Should only be used by legacy drivers, atomic 1070 * drivers should look at &drm_plane_state.crtc_y of the primary plane 1071 * instead. Updated by calling 1072 * drm_atomic_helper_update_legacy_modeset_state(). 1073 */ 1074 int y; 1075 1076 /** @funcs: CRTC control functions */ 1077 const struct drm_crtc_funcs *funcs; 1078 1079 /** 1080 * @gamma_size: Size of legacy gamma ramp reported to userspace. Set up 1081 * by calling drm_mode_crtc_set_gamma_size(). 1082 * 1083 * Note that atomic drivers need to instead use 1084 * &drm_crtc_state.gamma_lut. See drm_crtc_enable_color_mgmt(). 1085 */ 1086 uint32_t gamma_size; 1087 1088 /** 1089 * @gamma_store: Gamma ramp values used by the legacy SETGAMMA and 1090 * GETGAMMA IOCTls. Set up by calling drm_mode_crtc_set_gamma_size(). 1091 * 1092 * Note that atomic drivers need to instead use 1093 * &drm_crtc_state.gamma_lut. See drm_crtc_enable_color_mgmt(). 1094 */ 1095 uint16_t *gamma_store; 1096 1097 /** @helper_private: mid-layer private data */ 1098 const struct drm_crtc_helper_funcs *helper_private; 1099 1100 /** @properties: property tracking for this CRTC */ 1101 struct drm_object_properties properties; 1102 1103 /** 1104 * @scaling_filter_property: property to apply a particular filter while 1105 * scaling. 1106 */ 1107 struct drm_property *scaling_filter_property; 1108 1109 /** 1110 * @state: 1111 * 1112 * Current atomic state for this CRTC. 1113 * 1114 * This is protected by @mutex. Note that nonblocking atomic commits 1115 * access the current CRTC state without taking locks. Either by going 1116 * through the &struct drm_atomic_state pointers, see 1117 * for_each_oldnew_crtc_in_state(), for_each_old_crtc_in_state() and 1118 * for_each_new_crtc_in_state(). Or through careful ordering of atomic 1119 * commit operations as implemented in the atomic helpers, see 1120 * &struct drm_crtc_commit. 1121 */ 1122 struct drm_crtc_state *state; 1123 1124 /** 1125 * @commit_list: 1126 * 1127 * List of &drm_crtc_commit structures tracking pending commits. 1128 * Protected by @commit_lock. This list holds its own full reference, 1129 * as does the ongoing commit. 1130 * 1131 * "Note that the commit for a state change is also tracked in 1132 * &drm_crtc_state.commit. For accessing the immediately preceding 1133 * commit in an atomic update it is recommended to just use that 1134 * pointer in the old CRTC state, since accessing that doesn't need 1135 * any locking or list-walking. @commit_list should only be used to 1136 * stall for framebuffer cleanup that's signalled through 1137 * &drm_crtc_commit.cleanup_done." 1138 */ 1139 struct list_head commit_list; 1140 1141 /** 1142 * @commit_lock: 1143 * 1144 * Spinlock to protect @commit_list. 1145 */ 1146 spinlock_t commit_lock; 1147 1148 /** 1149 * @debugfs_entry: 1150 * 1151 * Debugfs directory for this CRTC. 1152 */ 1153 struct dentry *debugfs_entry; 1154 1155 /** 1156 * @crc: 1157 * 1158 * Configuration settings of CRC capture. 1159 */ 1160 struct drm_crtc_crc crc; 1161 1162 /** 1163 * @fence_context: 1164 * 1165 * timeline context used for fence operations. 1166 */ 1167 unsigned int fence_context; 1168 1169 /** 1170 * @fence_lock: 1171 * 1172 * spinlock to protect the fences in the fence_context. 1173 */ 1174 spinlock_t fence_lock; 1175 /** 1176 * @fence_seqno: 1177 * 1178 * Seqno variable used as monotonic counter for the fences 1179 * created on the CRTC's timeline. 1180 */ 1181 unsigned long fence_seqno; 1182 1183 /** 1184 * @timeline_name: 1185 * 1186 * The name of the CRTC's fence timeline. 1187 */ 1188 char timeline_name[32]; 1189 1190 /** 1191 * @self_refresh_data: Holds the state for the self refresh helpers 1192 * 1193 * Initialized via drm_self_refresh_helper_init(). 1194 */ 1195 struct drm_self_refresh_data *self_refresh_data; 1196 }; 1197 1198 /** 1199 * struct drm_mode_set - new values for a CRTC config change 1200 * @fb: framebuffer to use for new config 1201 * @crtc: CRTC whose configuration we're about to change 1202 * @mode: mode timings to use 1203 * @x: position of this CRTC relative to @fb 1204 * @y: position of this CRTC relative to @fb 1205 * @connectors: array of connectors to drive with this CRTC if possible 1206 * @num_connectors: size of @connectors array 1207 * 1208 * This represents a modeset configuration for the legacy SETCRTC ioctl and is 1209 * also used internally. Atomic drivers instead use &drm_atomic_state. 1210 */ 1211 struct drm_mode_set { 1212 struct drm_framebuffer *fb; 1213 struct drm_crtc *crtc; 1214 struct drm_display_mode *mode; 1215 1216 uint32_t x; 1217 uint32_t y; 1218 1219 struct drm_connector **connectors; 1220 size_t num_connectors; 1221 }; 1222 1223 #define obj_to_crtc(x) container_of(x, struct drm_crtc, base) 1224 1225 __printf(6, 7) 1226 int drm_crtc_init_with_planes(struct drm_device *dev, 1227 struct drm_crtc *crtc, 1228 struct drm_plane *primary, 1229 struct drm_plane *cursor, 1230 const struct drm_crtc_funcs *funcs, 1231 const char *name, ...); 1232 void drm_crtc_cleanup(struct drm_crtc *crtc); 1233 1234 __printf(7, 8) 1235 void *__drmm_crtc_alloc_with_planes(struct drm_device *dev, 1236 size_t size, size_t offset, 1237 struct drm_plane *primary, 1238 struct drm_plane *cursor, 1239 const struct drm_crtc_funcs *funcs, 1240 const char *name, ...); 1241 1242 /** 1243 * drmm_crtc_alloc_with_planes - Allocate and initialize a new CRTC object with 1244 * specified primary and cursor planes. 1245 * @dev: DRM device 1246 * @type: the type of the struct which contains struct &drm_crtc 1247 * @member: the name of the &drm_crtc within @type. 1248 * @primary: Primary plane for CRTC 1249 * @cursor: Cursor plane for CRTC 1250 * @funcs: callbacks for the new CRTC 1251 * @name: printf style format string for the CRTC name, or NULL for default name 1252 * 1253 * Allocates and initializes a new crtc object. Cleanup is automatically 1254 * handled through registering drmm_crtc_cleanup() with drmm_add_action(). 1255 * 1256 * The @drm_crtc_funcs.destroy hook must be NULL. 1257 * 1258 * Returns: 1259 * Pointer to new crtc, or ERR_PTR on failure. 1260 */ 1261 #define drmm_crtc_alloc_with_planes(dev, type, member, primary, cursor, funcs, name, ...) \ 1262 ((type *)__drmm_crtc_alloc_with_planes(dev, sizeof(type), \ 1263 offsetof(type, member), \ 1264 primary, cursor, funcs, \ 1265 name, ##__VA_ARGS__)) 1266 1267 /** 1268 * drm_crtc_index - find the index of a registered CRTC 1269 * @crtc: CRTC to find index for 1270 * 1271 * Given a registered CRTC, return the index of that CRTC within a DRM 1272 * device's list of CRTCs. 1273 */ 1274 static inline unsigned int drm_crtc_index(const struct drm_crtc *crtc) 1275 { 1276 return crtc->index; 1277 } 1278 1279 /** 1280 * drm_crtc_mask - find the mask of a registered CRTC 1281 * @crtc: CRTC to find mask for 1282 * 1283 * Given a registered CRTC, return the mask bit of that CRTC for the 1284 * &drm_encoder.possible_crtcs and &drm_plane.possible_crtcs fields. 1285 */ 1286 static inline uint32_t drm_crtc_mask(const struct drm_crtc *crtc) 1287 { 1288 return 1 << drm_crtc_index(crtc); 1289 } 1290 1291 int drm_mode_set_config_internal(struct drm_mode_set *set); 1292 struct drm_crtc *drm_crtc_from_index(struct drm_device *dev, int idx); 1293 1294 /** 1295 * drm_crtc_find - look up a CRTC object from its ID 1296 * @dev: DRM device 1297 * @file_priv: drm file to check for lease against. 1298 * @id: &drm_mode_object ID 1299 * 1300 * This can be used to look up a CRTC from its userspace ID. Only used by 1301 * drivers for legacy IOCTLs and interface, nowadays extensions to the KMS 1302 * userspace interface should be done using &drm_property. 1303 */ 1304 static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev, 1305 struct drm_file *file_priv, 1306 uint32_t id) 1307 { 1308 struct drm_mode_object *mo; 1309 mo = drm_mode_object_find(dev, file_priv, id, DRM_MODE_OBJECT_CRTC); 1310 return mo ? obj_to_crtc(mo) : NULL; 1311 } 1312 1313 /** 1314 * drm_for_each_crtc - iterate over all CRTCs 1315 * @crtc: a &struct drm_crtc as the loop cursor 1316 * @dev: the &struct drm_device 1317 * 1318 * Iterate over all CRTCs of @dev. 1319 */ 1320 #define drm_for_each_crtc(crtc, dev) \ 1321 list_for_each_entry(crtc, &(dev)->mode_config.crtc_list, head) 1322 1323 /** 1324 * drm_for_each_crtc_reverse - iterate over all CRTCs in reverse order 1325 * @crtc: a &struct drm_crtc as the loop cursor 1326 * @dev: the &struct drm_device 1327 * 1328 * Iterate over all CRTCs of @dev. 1329 */ 1330 #define drm_for_each_crtc_reverse(crtc, dev) \ 1331 list_for_each_entry_reverse(crtc, &(dev)->mode_config.crtc_list, head) 1332 1333 int drm_crtc_create_scaling_filter_property(struct drm_crtc *crtc, 1334 unsigned int supported_filters); 1335 1336 #endif /* __DRM_CRTC_H__ */ 1337