2 * Copyright © 2006 Keith Packard
3 * Copyright © 2007-2008 Dave Airlie
4 * Copyright © 2007-2008 Intel Corporation
5 * Jesse Barnes <jesse.barnes@intel.com>
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:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
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.
25 #ifndef __DRM_CRTC_H__
26 #define __DRM_CRTC_H__
28 #include <linux/i2c.h>
29 #include <linux/spinlock.h>
30 #include <linux/types.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_property.h>
43 #include <drm/drm_bridge.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>
60 static inline int64_t U642I64(uint64_t val)
62 return (int64_t)*((int64_t *)&val);
64 static inline uint64_t I642U64(int64_t val)
66 return (uint64_t)*((uint64_t *)&val);
70 struct drm_pending_vblank_event;
73 struct drm_atomic_state;
75 struct drm_crtc_helper_funcs;
76 struct drm_plane_helper_funcs;
79 * struct drm_crtc_state - mutable CRTC state
80 * @crtc: backpointer to the CRTC
81 * @enable: whether the CRTC should be enabled, gates all other state
82 * @active: whether the CRTC is actively displaying (used for DPMS)
83 * @planes_changed: planes on this crtc are updated
84 * @mode_changed: @mode or @enable has been changed
85 * @active_changed: @active has been toggled.
86 * @connectors_changed: connectors to this crtc have been updated
87 * @zpos_changed: zpos values of planes on this crtc have been updated
88 * @color_mgmt_changed: color management properties have changed (degamma or
89 * gamma LUT or CSC matrix)
90 * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes
91 * @connector_mask: bitmask of (1 << drm_connector_index(connector)) of attached connectors
92 * @encoder_mask: bitmask of (1 << drm_encoder_index(encoder)) of attached encoders
93 * @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings
94 * @mode: current mode timings
95 * @mode_blob: &drm_property_blob for @mode
96 * @degamma_lut: Lookup table for converting framebuffer pixel data
97 * before apply the conversion matrix
98 * @ctm: Transformation matrix
99 * @gamma_lut: Lookup table for converting pixel data after the
101 * @state: backpointer to global drm_atomic_state
103 * Note that the distinction between @enable and @active is rather subtile:
104 * Flipping @active while @enable is set without changing anything else may
105 * never return in a failure from the &drm_mode_config_funcs.atomic_check
106 * callback. Userspace assumes that a DPMS On will always succeed. In other
107 * words: @enable controls resource assignment, @active controls the actual
110 * The three booleans active_changed, connectors_changed and mode_changed are
111 * intended to indicate whether a full modeset is needed, rather than strictly
112 * describing what has changed in a commit.
113 * See also: drm_atomic_crtc_needs_modeset()
115 struct drm_crtc_state {
116 struct drm_crtc *crtc;
121 /* computed state bits used by helpers and drivers */
122 bool planes_changed : 1;
123 bool mode_changed : 1;
124 bool active_changed : 1;
125 bool connectors_changed : 1;
126 bool zpos_changed : 1;
127 bool color_mgmt_changed : 1;
129 /* attached planes bitmask:
130 * WARNING: transitional helpers do not maintain plane_mask so
131 * drivers not converted over to atomic helpers should not rely
132 * on plane_mask being accurate!
139 /* adjusted_mode: for use by helpers and drivers */
140 struct drm_display_mode adjusted_mode;
142 struct drm_display_mode mode;
144 /* blob property to expose current mode to atomic userspace */
145 struct drm_property_blob *mode_blob;
147 /* blob property to expose color management to userspace */
148 struct drm_property_blob *degamma_lut;
149 struct drm_property_blob *ctm;
150 struct drm_property_blob *gamma_lut;
155 * Target vertical blank period when a page flip
156 * should take effect.
164 * Optional pointer to a DRM event to signal upon completion of the
165 * state update. The driver must send out the event when the atomic
166 * commit operation completes. There are two cases:
168 * - The event is for a CRTC which is being disabled through this
169 * atomic commit. In that case the event can be send out any time
170 * after the hardware has stopped scanning out the current
171 * framebuffers. It should contain the timestamp and counter for the
172 * last vblank before the display pipeline was shut off.
174 * - For a CRTC which is enabled at the end of the commit (even when it
175 * undergoes an full modeset) the vblank timestamp and counter must
176 * be for the vblank right before the first frame that scans out the
177 * new set of buffers. Again the event can only be sent out after the
178 * hardware has stopped scanning out the old buffers.
180 * - Events for disabled CRTCs are not allowed, and drivers can ignore
183 * This can be handled by the drm_crtc_send_vblank_event() function,
184 * which the driver should call on the provided event upon completion of
185 * the atomic commit. Note that if the driver supports vblank signalling
186 * and timestamping the vblank counters and timestamps must agree with
187 * the ones returned from page flip events. With the current vblank
188 * helper infrastructure this can be achieved by holding a vblank
189 * reference while the page flip is pending, acquired through
190 * drm_crtc_vblank_get() and released with drm_crtc_vblank_put().
191 * Drivers are free to implement their own vblank counter and timestamp
192 * tracking though, e.g. if they have accurate timestamp registers in
195 * For hardware which supports some means to synchronize vblank
196 * interrupt delivery with committing display state there's also
197 * drm_crtc_arm_vblank_event(). See the documentation of that function
198 * for a detailed discussion of the constraints it needs to be used
201 struct drm_pending_vblank_event *event;
203 struct drm_atomic_state *state;
207 * struct drm_crtc_funcs - control CRTCs for a given device
209 * The drm_crtc_funcs structure is the central CRTC management structure
210 * in the DRM. Each CRTC controls one or more connectors (note that the name
211 * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc.
212 * connectors, not just CRTs).
214 * Each driver is responsible for filling out this structure at startup time,
215 * in addition to providing other modesetting features, like i2c and DDC
218 struct drm_crtc_funcs {
222 * Reset CRTC hardware and software state to off. This function isn't
223 * called by the core directly, only through drm_mode_config_reset().
224 * It's not a helper hook only for historical reasons.
226 * Atomic drivers can use drm_atomic_helper_crtc_reset() to reset
227 * atomic state using this hook.
229 void (*reset)(struct drm_crtc *crtc);
234 * Update the cursor image. The cursor position is relative to the CRTC
235 * and can be partially or fully outside of the visible area.
237 * Note that contrary to all other KMS functions the legacy cursor entry
238 * points don't take a framebuffer object, but instead take directly a
239 * raw buffer object id from the driver's buffer manager (which is
240 * either GEM or TTM for current drivers).
242 * This entry point is deprecated, drivers should instead implement
243 * universal plane support and register a proper cursor plane using
244 * drm_crtc_init_with_planes().
246 * This callback is optional
250 * 0 on success or a negative error code on failure.
252 int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv,
253 uint32_t handle, uint32_t width, uint32_t height);
258 * Update the cursor image, including hotspot information. The hotspot
259 * must not affect the cursor position in CRTC coordinates, but is only
260 * meant as a hint for virtualized display hardware to coordinate the
261 * guests and hosts cursor position. The cursor hotspot is relative to
262 * the cursor image. Otherwise this works exactly like @cursor_set.
264 * This entry point is deprecated, drivers should instead implement
265 * universal plane support and register a proper cursor plane using
266 * drm_crtc_init_with_planes().
268 * This callback is optional.
272 * 0 on success or a negative error code on failure.
274 int (*cursor_set2)(struct drm_crtc *crtc, struct drm_file *file_priv,
275 uint32_t handle, uint32_t width, uint32_t height,
276 int32_t hot_x, int32_t hot_y);
281 * Update the cursor position. The cursor does not need to be visible
282 * when this hook is called.
284 * This entry point is deprecated, drivers should instead implement
285 * universal plane support and register a proper cursor plane using
286 * drm_crtc_init_with_planes().
288 * This callback is optional.
292 * 0 on success or a negative error code on failure.
294 int (*cursor_move)(struct drm_crtc *crtc, int x, int y);
299 * Set gamma on the CRTC.
301 * This callback is optional.
305 * Drivers that support gamma tables and also fbdev emulation through
306 * the provided helper library need to take care to fill out the gamma
307 * hooks for both. Currently there's a bit an unfortunate duplication
308 * going on, which should eventually be unified to just one set of
311 int (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
317 * Clean up plane resources. This is only called at driver unload time
318 * through drm_mode_config_cleanup() since a CRTC cannot be hotplugged
321 void (*destroy)(struct drm_crtc *crtc);
326 * This is the main legacy entry point to change the modeset state on a
327 * CRTC. All the details of the desired configuration are passed in a
328 * &struct drm_mode_set - see there for details.
330 * Drivers implementing atomic modeset should use
331 * drm_atomic_helper_set_config() to implement this hook.
335 * 0 on success or a negative error code on failure.
337 int (*set_config)(struct drm_mode_set *set);
342 * Legacy entry point to schedule a flip to the given framebuffer.
344 * Page flipping is a synchronization mechanism that replaces the frame
345 * buffer being scanned out by the CRTC with a new frame buffer during
346 * vertical blanking, avoiding tearing (except when requested otherwise
347 * through the DRM_MODE_PAGE_FLIP_ASYNC flag). When an application
348 * requests a page flip the DRM core verifies that the new frame buffer
349 * is large enough to be scanned out by the CRTC in the currently
350 * configured mode and then calls this hook with a pointer to the new
353 * The driver must wait for any pending rendering to the new framebuffer
354 * to complete before executing the flip. It should also wait for any
355 * pending rendering from other drivers if the underlying buffer is a
358 * An application can request to be notified when the page flip has
359 * completed. The drm core will supply a &struct drm_event in the event
360 * parameter in this case. This can be handled by the
361 * drm_crtc_send_vblank_event() function, which the driver should call on
362 * the provided event upon completion of the flip. Note that if
363 * the driver supports vblank signalling and timestamping the vblank
364 * counters and timestamps must agree with the ones returned from page
365 * flip events. With the current vblank helper infrastructure this can
366 * be achieved by holding a vblank reference while the page flip is
367 * pending, acquired through drm_crtc_vblank_get() and released with
368 * drm_crtc_vblank_put(). Drivers are free to implement their own vblank
369 * counter and timestamp tracking though, e.g. if they have accurate
370 * timestamp registers in hardware.
372 * This callback is optional.
376 * Very early versions of the KMS ABI mandated that the driver must
377 * block (but not reject) any rendering to the old framebuffer until the
378 * flip operation has completed and the old framebuffer is no longer
379 * visible. This requirement has been lifted, and userspace is instead
380 * expected to request delivery of an event and wait with recycling old
381 * buffers until such has been received.
385 * 0 on success or a negative error code on failure. Note that if a
386 * page flip operation is already pending the callback should return
387 * -EBUSY. Pageflips on a disabled CRTC (either by setting a NULL mode
388 * or just runtime disabled through DPMS respectively the new atomic
389 * "ACTIVE" state) should result in an -EINVAL error code. Note that
390 * drm_atomic_helper_page_flip() checks this already for atomic drivers.
392 int (*page_flip)(struct drm_crtc *crtc,
393 struct drm_framebuffer *fb,
394 struct drm_pending_vblank_event *event,
400 * Same as @page_flip but with an additional parameter specifying the
401 * absolute target vertical blank period (as reported by
402 * drm_crtc_vblank_count()) when the flip should take effect.
404 * Note that the core code calls drm_crtc_vblank_get before this entry
405 * point, and will call drm_crtc_vblank_put if this entry point returns
406 * any non-0 error code. It's the driver's responsibility to call
407 * drm_crtc_vblank_put after this entry point returns 0, typically when
408 * the flip completes.
410 int (*page_flip_target)(struct drm_crtc *crtc,
411 struct drm_framebuffer *fb,
412 struct drm_pending_vblank_event *event,
413 uint32_t flags, uint32_t target);
418 * This is the legacy entry point to update a property attached to the
421 * Drivers implementing atomic modeset should use
422 * drm_atomic_helper_crtc_set_property() to implement this hook.
424 * This callback is optional if the driver does not support any legacy
425 * driver-private properties.
429 * 0 on success or a negative error code on failure.
431 int (*set_property)(struct drm_crtc *crtc,
432 struct drm_property *property, uint64_t val);
435 * @atomic_duplicate_state:
437 * Duplicate the current atomic state for this CRTC and return it.
438 * The core and helpers guarantee that any atomic state duplicated with
439 * this hook and still owned by the caller (i.e. not transferred to the
440 * driver by calling &drm_mode_config_funcs.atomic_commit) will be
441 * cleaned up by calling the @atomic_destroy_state hook in this
444 * Atomic drivers which don't subclass &struct drm_crtc_state should use
445 * drm_atomic_helper_crtc_duplicate_state(). Drivers that subclass the
446 * state structure to extend it with driver-private state should use
447 * __drm_atomic_helper_crtc_duplicate_state() to make sure shared state is
448 * duplicated in a consistent fashion across drivers.
450 * It is an error to call this hook before &drm_crtc.state has been
451 * initialized correctly.
455 * If the duplicate state references refcounted resources this hook must
456 * acquire a reference for each of them. The driver must release these
457 * references again in @atomic_destroy_state.
461 * Duplicated atomic state or NULL when the allocation failed.
463 struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc);
466 * @atomic_destroy_state:
468 * Destroy a state duplicated with @atomic_duplicate_state and release
469 * or unreference all resources it references
471 void (*atomic_destroy_state)(struct drm_crtc *crtc,
472 struct drm_crtc_state *state);
475 * @atomic_set_property:
477 * Decode a driver-private property value and store the decoded value
478 * into the passed-in state structure. Since the atomic core decodes all
479 * standardized properties (even for extensions beyond the core set of
480 * properties which might not be implemented by all drivers) this
481 * requires drivers to subclass the state structure.
483 * Such driver-private properties should really only be implemented for
484 * truly hardware/vendor specific state. Instead it is preferred to
485 * standardize atomic extension and decode the properties used to expose
486 * such an extension in the core.
488 * Do not call this function directly, use
489 * drm_atomic_crtc_set_property() instead.
491 * This callback is optional if the driver does not support any
492 * driver-private atomic properties.
496 * This function is called in the state assembly phase of atomic
497 * modesets, which can be aborted for any reason (including on
498 * userspace's request to just check whether a configuration would be
499 * possible). Drivers MUST NOT touch any persistent state (hardware or
500 * software) or data structures except the passed in @state parameter.
502 * Also since userspace controls in which order properties are set this
503 * function must not do any input validation (since the state update is
504 * incomplete and hence likely inconsistent). Instead any such input
505 * validation must be done in the various atomic_check callbacks.
509 * 0 if the property has been found, -EINVAL if the property isn't
510 * implemented by the driver (which should never happen, the core only
511 * asks for properties attached to this CRTC). No other validation is
512 * allowed by the driver. The core already checks that the property
513 * value is within the range (integer, valid enum value, ...) the driver
514 * set when registering the property.
516 int (*atomic_set_property)(struct drm_crtc *crtc,
517 struct drm_crtc_state *state,
518 struct drm_property *property,
521 * @atomic_get_property:
523 * Reads out the decoded driver-private property. This is used to
524 * implement the GETCRTC IOCTL.
526 * Do not call this function directly, use
527 * drm_atomic_crtc_get_property() instead.
529 * This callback is optional if the driver does not support any
530 * driver-private atomic properties.
534 * 0 on success, -EINVAL if the property isn't implemented by the
535 * driver (which should never happen, the core only asks for
536 * properties attached to this CRTC).
538 int (*atomic_get_property)(struct drm_crtc *crtc,
539 const struct drm_crtc_state *state,
540 struct drm_property *property,
546 * This optional hook can be used to register additional userspace
547 * interfaces attached to the crtc like debugfs interfaces.
548 * It is called late in the driver load sequence from drm_dev_register().
549 * Everything added from this callback should be unregistered in
550 * the early_unregister callback.
554 * 0 on success, or a negative error code on failure.
556 int (*late_register)(struct drm_crtc *crtc);
561 * This optional hook should be used to unregister the additional
562 * userspace interfaces attached to the crtc from
563 * late_unregister(). It is called from drm_dev_unregister(),
564 * early in the driver unload sequence to disable userspace access
565 * before data structures are torndown.
567 void (*early_unregister)(struct drm_crtc *crtc);
572 * Changes the source of CRC checksums of frames at the request of
573 * userspace, typically for testing purposes. The sources available are
574 * specific of each driver and a %NULL value indicates that CRC
575 * generation is to be switched off.
577 * When CRC generation is enabled, the driver should call
578 * drm_crtc_add_crc_entry() at each frame, providing any information
579 * that characterizes the frame contents in the crcN arguments, as
580 * provided from the configured source. Drivers must accept a "auto"
581 * source name that will select a default source for this CRTC.
583 * This callback is optional if the driver does not support any CRC
584 * generation functionality.
588 * 0 on success or a negative error code on failure.
590 int (*set_crc_source)(struct drm_crtc *crtc, const char *source,
594 * @atomic_print_state:
596 * If driver subclasses &struct drm_crtc_state, it should implement
597 * this optional hook for printing additional driver specific state.
599 * Do not call this directly, use drm_atomic_crtc_print_state()
602 void (*atomic_print_state)(struct drm_printer *p,
603 const struct drm_crtc_state *state);
607 * struct drm_crtc - central CRTC control structure
608 * @dev: parent DRM device
609 * @port: OF node used by drm_of_find_possible_crtcs()
610 * @head: list management
611 * @name: human readable name, can be overwritten by the driver
612 * @mutex: per-CRTC locking
613 * @base: base KMS object for ID tracking etc.
614 * @primary: primary plane for this CRTC
615 * @cursor: cursor plane for this CRTC
616 * @cursor_x: current x position of the cursor, used for universal cursor planes
617 * @cursor_y: current y position of the cursor, used for universal cursor planes
618 * @enabled: is this CRTC enabled?
619 * @mode: current mode timings
620 * @hwmode: mode timings as programmed to hw regs
621 * @x: x position on screen
622 * @y: y position on screen
623 * @funcs: CRTC control functions
624 * @gamma_size: size of gamma ramp
625 * @gamma_store: gamma ramp values
626 * @helper_private: mid-layer private data
627 * @properties: property tracking for this CRTC
629 * Each CRTC may have one or more connectors associated with it. This structure
630 * allows the CRTC to be controlled.
633 struct drm_device *dev;
634 struct device_node *port;
635 struct list_head head;
642 * This provides a read lock for the overall crtc state (mode, dpms
643 * state, ...) and a write lock for everything which can be update
644 * without a full modeset (fb, cursor data, crtc properties ...). A full
645 * modeset also need to grab &drm_mode_config.connection_mutex.
647 struct drm_modeset_lock mutex;
649 struct drm_mode_object base;
651 /* primary and cursor planes for CRTC */
652 struct drm_plane *primary;
653 struct drm_plane *cursor;
656 * @index: Position inside the mode_config.list, can be used as an array
657 * index. It is invariant over the lifetime of the CRTC.
661 /* position of cursor plane on crtc */
667 /* Requested mode from modesetting. */
668 struct drm_display_mode mode;
670 /* Programmed mode in hw, after adjustments for encoders,
671 * crtc, panel scaling etc. Needed for timestamping etc.
673 struct drm_display_mode hwmode;
676 const struct drm_crtc_funcs *funcs;
678 /* Legacy FB CRTC gamma size for reporting to userspace */
680 uint16_t *gamma_store;
682 /* if you are using the helper */
683 const struct drm_crtc_helper_funcs *helper_private;
685 struct drm_object_properties properties;
690 * Current atomic state for this CRTC.
692 struct drm_crtc_state *state;
697 * List of &drm_crtc_commit structures tracking pending commits.
698 * Protected by @commit_lock. This list doesn't hold its own full
699 * reference, but burrows it from the ongoing commit. Commit entries
700 * must be removed from this list once the commit is fully completed,
701 * but before it's correspoding &drm_atomic_state gets destroyed.
703 struct list_head commit_list;
708 * Spinlock to protect @commit_list.
710 spinlock_t commit_lock;
715 * Per-CRTC implicit acquire context used by atomic drivers for legacy
716 * IOCTLs, so that atomic drivers can get at the locking acquire
719 struct drm_modeset_acquire_ctx *acquire_ctx;
721 #ifdef CONFIG_DEBUG_FS
725 * Debugfs directory for this CRTC.
727 struct dentry *debugfs_entry;
732 * Configuration settings of CRC capture.
734 struct drm_crtc_crc crc;
740 * timeline context used for fence operations.
742 unsigned int fence_context;
747 * spinlock to protect the fences in the fence_context.
750 spinlock_t fence_lock;
754 * Seqno variable used as monotonic counter for the fences
755 * created on the CRTC's timeline.
757 unsigned long fence_seqno;
762 * The name of the CRTC's fence timeline.
764 char timeline_name[32];
768 * struct drm_mode_set - new values for a CRTC config change
769 * @fb: framebuffer to use for new config
770 * @crtc: CRTC whose configuration we're about to change
771 * @mode: mode timings to use
772 * @x: position of this CRTC relative to @fb
773 * @y: position of this CRTC relative to @fb
774 * @connectors: array of connectors to drive with this CRTC if possible
775 * @num_connectors: size of @connectors array
777 * This represents a modeset configuration for the legacy SETCRTC ioctl and is
778 * also used internally. Atomic drivers instead use &drm_atomic_state.
780 struct drm_mode_set {
781 struct drm_framebuffer *fb;
782 struct drm_crtc *crtc;
783 struct drm_display_mode *mode;
788 struct drm_connector **connectors;
789 size_t num_connectors;
792 #define obj_to_crtc(x) container_of(x, struct drm_crtc, base)
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);
804 * drm_crtc_index - find the index of a registered CRTC
805 * @crtc: CRTC to find index for
807 * Given a registered CRTC, return the index of that CRTC within a DRM
808 * device's list of CRTCs.
810 static inline unsigned int drm_crtc_index(const struct drm_crtc *crtc)
816 * drm_crtc_mask - find the mask of a registered CRTC
817 * @crtc: CRTC to find mask for
819 * Given a registered CRTC, return the mask bit of that CRTC for an
820 * encoder's possible_crtcs field.
822 static inline uint32_t drm_crtc_mask(const struct drm_crtc *crtc)
824 return 1 << drm_crtc_index(crtc);
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);
832 int drm_mode_set_config_internal(struct drm_mode_set *set);
833 struct drm_crtc *drm_crtc_from_index(struct drm_device *dev, int idx);
836 * drm_crtc_find - look up a CRTC object from its ID
838 * @id: &drm_mode_object ID
840 * This can be used to look up a CRTC from its userspace ID. Only used by
841 * drivers for legacy IOCTLs and interface, nowadays extensions to the KMS
842 * userspace interface should be done using &drm_property.
844 static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev,
847 struct drm_mode_object *mo;
848 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CRTC);
849 return mo ? obj_to_crtc(mo) : NULL;
853 * drm_for_each_crtc - iterate over all CRTCs
854 * @crtc: a &struct drm_crtc as the loop cursor
855 * @dev: the &struct drm_device
857 * Iterate over all CRTCs of @dev.
859 #define drm_for_each_crtc(crtc, dev) \
860 list_for_each_entry(crtc, &(dev)->mode_config.crtc_list, head)
862 #endif /* __DRM_CRTC_H__ */