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