drm_crtc.h 82.1 KB
Newer Older
D
Dave Airlie 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
/*
 * Copyright © 2006 Keith Packard
 * Copyright © 2007-2008 Dave Airlie
 * Copyright © 2007-2008 Intel Corporation
 *   Jesse Barnes <jesse.barnes@intel.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */
#ifndef __DRM_CRTC_H__
#define __DRM_CRTC_H__

#include <linux/i2c.h>
#include <linux/spinlock.h>
#include <linux/types.h>
#include <linux/idr.h>
#include <linux/fb.h>
33
#include <linux/hdmi.h>
34
#include <linux/media-bus-format.h>
35 36
#include <uapi/drm/drm_mode.h>
#include <uapi/drm/drm_fourcc.h>
37
#include <drm/drm_modeset_lock.h>
38

D
Dave Airlie 已提交
39 40 41
struct drm_device;
struct drm_mode_set;
struct drm_framebuffer;
42
struct drm_object_properties;
43 44
struct drm_file;
struct drm_clip_rect;
45
struct device_node;
46
struct fence;
D
Dave Airlie 已提交
47 48 49 50 51 52 53 54

#define DRM_MODE_OBJECT_CRTC 0xcccccccc
#define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0
#define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0
#define DRM_MODE_OBJECT_MODE 0xdededede
#define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0
#define DRM_MODE_OBJECT_FB 0xfbfbfbfb
#define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb
J
Jesse Barnes 已提交
55
#define DRM_MODE_OBJECT_PLANE 0xeeeeeeee
R
Rob Clark 已提交
56
#define DRM_MODE_OBJECT_ANY 0
D
Dave Airlie 已提交
57 58 59 60

struct drm_mode_object {
	uint32_t id;
	uint32_t type;
61 62 63
	struct drm_object_properties *properties;
};

64
#define DRM_OBJECT_MAX_PROPERTY 24
65
struct drm_object_properties {
R
Rob Clark 已提交
66
	int count, atomic_count;
67 68 69 70 71 72
	/* NOTE: if we ever start dynamically destroying properties (ie.
	 * not at drm_mode_config_cleanup() time), then we'd have to do
	 * a better job of detaching property from mode objects to avoid
	 * dangling property pointers:
	 */
	struct drm_property *properties[DRM_OBJECT_MAX_PROPERTY];
73 74 75
	/* do not read/write values directly, but use drm_object_property_get_value()
	 * and drm_object_property_set_value():
	 */
76
	uint64_t values[DRM_OBJECT_MAX_PROPERTY];
D
Dave Airlie 已提交
77 78
};

R
Rob Clark 已提交
79 80 81 82 83 84 85 86 87
static inline int64_t U642I64(uint64_t val)
{
	return (int64_t)*((int64_t *)&val);
}
static inline uint64_t I642U64(int64_t val)
{
	return (uint64_t)*((uint64_t *)&val);
}

88 89 90 91 92
/*
 * Rotation property bits. DRM_ROTATE_<degrees> rotates the image by the
 * specified amount in degrees in counter clockwise direction. DRM_REFLECT_X and
 * DRM_REFLECT_Y reflects the image along the specified axis prior to rotation
 */
93
#define DRM_ROTATE_MASK 0x0f
94 95 96 97
#define DRM_ROTATE_0	0
#define DRM_ROTATE_90	1
#define DRM_ROTATE_180	2
#define DRM_ROTATE_270	3
98
#define DRM_REFLECT_MASK (~DRM_ROTATE_MASK)
99 100 101
#define DRM_REFLECT_X	4
#define DRM_REFLECT_Y	5

102 103 104 105 106
enum drm_connector_force {
	DRM_FORCE_UNSPECIFIED,
	DRM_FORCE_OFF,
	DRM_FORCE_ON,         /* force on analog part normally */
	DRM_FORCE_ON_DIGITAL, /* for DVI-I use digital connector */
D
Dave Airlie 已提交
107 108
};

109
#include <drm/drm_modes.h>
110

D
Dave Airlie 已提交
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
enum drm_connector_status {
	connector_status_connected = 1,
	connector_status_disconnected = 2,
	connector_status_unknown = 3,
};

enum subpixel_order {
	SubPixelUnknown = 0,
	SubPixelHorizontalRGB,
	SubPixelHorizontalBGR,
	SubPixelVerticalRGB,
	SubPixelVerticalBGR,
	SubPixelNone,
};

126 127 128
#define DRM_COLOR_FORMAT_RGB444		(1<<0)
#define DRM_COLOR_FORMAT_YCRCB444	(1<<1)
#define DRM_COLOR_FORMAT_YCRCB422	(1<<2)
D
Dave Airlie 已提交
129 130 131 132 133
/*
 * Describes a given display (e.g. CRT or flat panel) and its limitations.
 */
struct drm_display_info {
	char name[DRM_DISPLAY_INFO_LEN];
134

D
Dave Airlie 已提交
135 136 137 138 139 140 141 142
	/* Physical size */
        unsigned int width_mm;
	unsigned int height_mm;

	/* Clock limits FIXME: storage format */
	unsigned int min_vfreq, max_vfreq;
	unsigned int min_hfreq, max_hfreq;
	unsigned int pixel_clock;
J
Jesse Barnes 已提交
143
	unsigned int bpc;
D
Dave Airlie 已提交
144 145

	enum subpixel_order subpixel_order;
146
	u32 color_formats;
D
Dave Airlie 已提交
147

148 149 150
	const u32 *bus_formats;
	unsigned int num_bus_formats;

151 152 153
	/* Mask of supported hdmi deep color modes */
	u8 edid_hdmi_dc_modes;

154
	u8 cea_rev;
D
Dave Airlie 已提交
155 156
};

D
Dave Airlie 已提交
157 158 159 160 161 162 163 164
/* data corresponds to displayid vend/prod/serial */
struct drm_tile_group {
	struct kref refcount;
	struct drm_device *dev;
	int id;
	u8 group_data[8];
};

165 166 167
/**
 * struct drm_framebuffer_funcs - framebuffer hooks
 */
D
Dave Airlie 已提交
168
struct drm_framebuffer_funcs {
169 170 171 172 173 174 175 176
	/**
	 * @destroy:
	 *
	 * Clean up framebuffer resources, specifically also unreference the
	 * backing storage. The core guarantees to call this function for every
	 * framebuffer successfully created by ->fb_create() in
	 * &drm_mode_config_funcs.
	 */
D
Dave Airlie 已提交
177
	void (*destroy)(struct drm_framebuffer *framebuffer);
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193

	/**
	 * @create_handle:
	 *
	 * Create a buffer handle in the driver-specific buffer manager (either
	 * GEM or TTM) valid for the passed-in struct &drm_file. This is used by
	 * the core to implement the GETFB IOCTL, which returns (for
	 * sufficiently priviledged user) also a native buffer handle. This can
	 * be used for seamless transitions between modesetting clients by
	 * copying the current screen contents to a private buffer and blending
	 * between that and the new contents.
	 *
	 * RETURNS:
	 *
	 * 0 on success or a negative error code on failure.
	 */
D
Dave Airlie 已提交
194 195 196
	int (*create_handle)(struct drm_framebuffer *fb,
			     struct drm_file *file_priv,
			     unsigned int *handle);
197 198
	/**
	 * @dirty:
199
	 *
200
	 * Optional callback for the dirty fb IOCTL.
201
	 *
202 203 204 205 206 207 208 209 210 211 212 213
	 * Userspace can notify the driver via this callback that an area of the
	 * framebuffer has changed and should be flushed to the display
	 * hardware. This can also be used internally, e.g. by the fbdev
	 * emulation, though that's not the case currently.
	 *
	 * See documentation in drm_mode.h for the struct drm_mode_fb_dirty_cmd
	 * for more information as all the semantics and arguments have a one to
	 * one mapping on this function.
	 *
	 * RETURNS:
	 *
	 * 0 on success or a negative error code on failure.
214
	 */
215 216
	int (*dirty)(struct drm_framebuffer *framebuffer,
		     struct drm_file *file_priv, unsigned flags,
217 218
		     unsigned color, struct drm_clip_rect *clips,
		     unsigned num_clips);
D
Dave Airlie 已提交
219 220 221 222
};

struct drm_framebuffer {
	struct drm_device *dev;
R
Rob Clark 已提交
223 224 225 226 227 228 229 230 231 232
	/*
	 * Note that the fb is refcounted for the benefit of driver internals,
	 * for example some hw, disabling a CRTC/plane is asynchronous, and
	 * scanout does not actually complete until the next vblank.  So some
	 * cleanup (like releasing the reference(s) on the backing GEM bo(s))
	 * should be deferred.  In cases like this, the driver would like to
	 * hold a ref to the fb even though it has already been removed from
	 * userspace perspective.
	 */
	struct kref refcount;
233 234 235 236
	/*
	 * Place on the dev->mode_config.fb_list, access protected by
	 * dev->mode_config.fb_lock.
	 */
D
Dave Airlie 已提交
237 238 239
	struct list_head head;
	struct drm_mode_object base;
	const struct drm_framebuffer_funcs *funcs;
240 241
	unsigned int pitches[4];
	unsigned int offsets[4];
242
	uint64_t modifier[4];
D
Dave Airlie 已提交
243 244 245 246 247 248
	unsigned int width;
	unsigned int height;
	/* depth can be 15 or 16 */
	unsigned int depth;
	int bits_per_pixel;
	int flags;
249
	uint32_t pixel_format; /* fourcc format */
D
Dave Airlie 已提交
250 251 252 253 254
	struct list_head filp_head;
};

struct drm_property_blob {
	struct drm_mode_object base;
255 256
	struct drm_device *dev;
	struct kref refcount;
257 258
	struct list_head head_global;
	struct list_head head_file;
259
	size_t length;
260
	unsigned char data[];
D
Dave Airlie 已提交
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
};

struct drm_property_enum {
	uint64_t value;
	struct list_head head;
	char name[DRM_PROP_NAME_LEN];
};

struct drm_property {
	struct list_head head;
	struct drm_mode_object base;
	uint32_t flags;
	char name[DRM_PROP_NAME_LEN];
	uint32_t num_values;
	uint64_t *values;
R
Rob Clark 已提交
276
	struct drm_device *dev;
D
Dave Airlie 已提交
277

278
	struct list_head enum_list;
D
Dave Airlie 已提交
279 280 281 282 283
};

struct drm_crtc;
struct drm_connector;
struct drm_encoder;
284
struct drm_pending_vblank_event;
J
Jesse Barnes 已提交
285
struct drm_plane;
S
Sean Paul 已提交
286
struct drm_bridge;
287 288
struct drm_atomic_state;

289 290 291 292 293
struct drm_crtc_helper_funcs;
struct drm_encoder_helper_funcs;
struct drm_connector_helper_funcs;
struct drm_plane_helper_funcs;

294
/**
D
Daniel Vetter 已提交
295
 * struct drm_crtc_state - mutable CRTC state
296
 * @crtc: backpointer to the CRTC
297
 * @enable: whether the CRTC should be enabled, gates all other state
298
 * @active: whether the CRTC is actively displaying (used for DPMS)
299 300 301 302
 * @planes_changed: planes on this crtc are updated
 * @mode_changed: crtc_state->mode or crtc_state->enable has been changed
 * @active_changed: crtc_state->active has been toggled.
 * @connectors_changed: connectors to this crtc have been updated
303
 * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes
304 305
 * @last_vblank_count: for helpers and drivers to capture the vblank of the
 * 	update to ensure framebuffer cleanup isn't done too early
306
 * @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings
307 308 309 310
 * @mode: current mode timings
 * @event: optional pointer to a DRM event to signal upon completion of the
 * 	state update
 * @state: backpointer to global drm_atomic_state
311 312 313 314 315 316
 *
 * Note that the distinction between @enable and @active is rather subtile:
 * Flipping @active while @enable is set without changing anything else may
 * never return in a failure from the ->atomic_check callback. Userspace assumes
 * that a DPMS On will always succeed. In other words: @enable controls resource
 * assignment, @active controls the actual hardware state.
317 318
 */
struct drm_crtc_state {
319 320
	struct drm_crtc *crtc;

D
Daniel Vetter 已提交
321
	bool enable;
322
	bool active;
323

D
Daniel Vetter 已提交
324 325
	/* computed state bits used by helpers and drivers */
	bool planes_changed : 1;
326
	bool mode_changed : 1;
327
	bool active_changed : 1;
328
	bool connectors_changed : 1;
329

330 331 332 333 334 335 336
	/* attached planes bitmask:
	 * WARNING: transitional helpers do not maintain plane_mask so
	 * drivers not converted over to atomic helpers should not rely
	 * on plane_mask being accurate!
	 */
	u32 plane_mask;

337 338
	/* last_vblank_count: for vblank waits before cleanup */
	u32 last_vblank_count;
D
Daniel Vetter 已提交
339

340 341 342
	/* adjusted_mode: for use by helpers and drivers */
	struct drm_display_mode adjusted_mode;

343 344
	struct drm_display_mode mode;

345 346 347
	/* blob property to expose current mode to atomic userspace */
	struct drm_property_blob *mode_blob;

348 349 350 351
	struct drm_pending_vblank_event *event;

	struct drm_atomic_state *state;
};
D
Dave Airlie 已提交
352 353

/**
354
 * struct drm_crtc_funcs - control CRTCs for a given device
D
Dave Airlie 已提交
355 356 357 358 359 360 361 362 363 364 365
 *
 * The drm_crtc_funcs structure is the central CRTC management structure
 * in the DRM.  Each CRTC controls one or more connectors (note that the name
 * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc.
 * connectors, not just CRTs).
 *
 * Each driver is responsible for filling out this structure at startup time,
 * in addition to providing other modesetting features, like i2c and DDC
 * bus accessors.
 */
struct drm_crtc_funcs {
366 367 368 369 370 371 372 373 374 375
	/**
	 * @reset:
	 *
	 * Reset CRTC hardware and software state to off. This function isn't
	 * called by the core directly, only through drm_mode_config_reset().
	 * It's not a helper hook only for historical reasons.
	 *
	 * Atomic drivers can use drm_atomic_helper_crtc_reset() to reset
	 * atomic state using this hook.
	 */
376
	void (*reset)(struct drm_crtc *crtc);
D
Dave Airlie 已提交
377

D
Daniel Vetter 已提交
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
	/**
	 * @cursor_set:
	 *
	 * Update the cursor image. The cursor position is relative to the CRTC
	 * and can be partially or fully outside of the visible area.
	 *
	 * Note that contrary to all other KMS functions the legacy cursor entry
	 * points don't take a framebuffer object, but instead take directly a
	 * raw buffer object id from the driver's buffer manager (which is
	 * either GEM or TTM for current drivers).
	 *
	 * This entry point is deprecated, drivers should instead implement
	 * universal plane support and register a proper cursor plane using
	 * drm_crtc_init_with_planes().
	 *
	 * This callback is optional
	 *
	 * RETURNS:
	 *
	 * 0 on success or a negative error code on failure.
	 */
D
Dave Airlie 已提交
399 400
	int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv,
			  uint32_t handle, uint32_t width, uint32_t height);
D
Daniel Vetter 已提交
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420

	/**
	 * @cursor_set2:
	 *
	 * Update the cursor image, including hotspot information. The hotspot
	 * must not affect the cursor position in CRTC coordinates, but is only
	 * meant as a hint for virtualized display hardware to coordinate the
	 * guests and hosts cursor position. The cursor hotspot is relative to
	 * the cursor image. Otherwise this works exactly like @cursor_set.
	 *
	 * This entry point is deprecated, drivers should instead implement
	 * universal plane support and register a proper cursor plane using
	 * drm_crtc_init_with_planes().
	 *
	 * This callback is optional.
	 *
	 * RETURNS:
	 *
	 * 0 on success or a negative error code on failure.
	 */
421 422 423
	int (*cursor_set2)(struct drm_crtc *crtc, struct drm_file *file_priv,
			   uint32_t handle, uint32_t width, uint32_t height,
			   int32_t hot_x, int32_t hot_y);
D
Daniel Vetter 已提交
424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440

	/**
	 * @cursor_move:
	 *
	 * Update the cursor position. The cursor does not need to be visible
	 * when this hook is called.
	 *
	 * This entry point is deprecated, drivers should instead implement
	 * universal plane support and register a proper cursor plane using
	 * drm_crtc_init_with_planes().
	 *
	 * This callback is optional.
	 *
	 * RETURNS:
	 *
	 * 0 on success or a negative error code on failure.
	 */
D
Dave Airlie 已提交
441 442
	int (*cursor_move)(struct drm_crtc *crtc, int x, int y);

D
Daniel Vetter 已提交
443 444 445 446 447 448 449 450 451 452 453 454 455 456 457
	/**
	 * @gamma_set:
	 *
	 * Set gamma on the CRTC.
	 *
	 * This callback is optional.
	 *
	 * NOTE:
	 *
	 * Drivers that support gamma tables and also fbdev emulation through
	 * the provided helper library need to take care to fill out the gamma
	 * hooks for both. Currently there's a bit an unfortunate duplication
	 * going on, which should eventually be unified to just one set of
	 * hooks.
	 */
D
Dave Airlie 已提交
458
	void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
J
James Simmons 已提交
459
			  uint32_t start, uint32_t size);
460 461 462 463 464 465 466 467

	/**
	 * @destroy:
	 *
	 * Clean up plane resources. This is only called at driver unload time
	 * through drm_mode_config_cleanup() since a CRTC cannot be hotplugged
	 * in DRM.
	 */
D
Dave Airlie 已提交
468 469
	void (*destroy)(struct drm_crtc *crtc);

D
Daniel Vetter 已提交
470 471 472 473 474 475 476 477 478 479 480 481 482 483
	/**
	 * @set_config:
	 *
	 * This is the main legacy entry point to change the modeset state on a
	 * CRTC. All the details of the desired configuration are passed in a
	 * struct &drm_mode_set - see there for details.
	 *
	 * Drivers implementing atomic modeset should use
	 * drm_atomic_helper_set_config() to implement this hook.
	 *
	 * RETURNS:
	 *
	 * 0 on success or a negative error code on failure.
	 */
D
Dave Airlie 已提交
484
	int (*set_config)(struct drm_mode_set *set);
485

D
Daniel Vetter 已提交
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
	/**
	 * @page_flip:
	 *
	 * Legacy entry point to schedule a flip to the given framebuffer.
	 *
	 * Page flipping is a synchronization mechanism that replaces the frame
	 * buffer being scanned out by the CRTC with a new frame buffer during
	 * vertical blanking, avoiding tearing (except when requested otherwise
	 * through the DRM_MODE_PAGE_FLIP_ASYNC flag). When an application
	 * requests a page flip the DRM core verifies that the new frame buffer
	 * is large enough to be scanned out by the CRTC in the currently
	 * configured mode and then calls the CRTC ->page_flip() operation with a
	 * pointer to the new frame buffer.
	 *
	 * The driver must wait for any pending rendering to the new framebuffer
	 * to complete before executing the flip. It should also wait for any
	 * pending rendering from other drivers if the underlying buffer is a
	 * shared dma-buf.
	 *
	 * An application can request to be notified when the page flip has
	 * completed. The drm core will supply a struct &drm_event in the event
	 * parameter in this case. This can be handled by the
	 * drm_crtc_send_vblank_event() function, which the driver should call on
	 * the provided event upon completion of the flip. Note that if
	 * the driver supports vblank signalling and timestamping the vblank
	 * counters and timestamps must agree with the ones returned from page
	 * flip events. With the current vblank helper infrastructure this can
	 * be achieved by holding a vblank reference while the page flip is
	 * pending, acquired through drm_crtc_vblank_get() and released with
	 * drm_crtc_vblank_put(). Drivers are free to implement their own vblank
	 * counter and timestamp tracking though, e.g. if they have accurate
	 * timestamp registers in hardware.
	 *
	 * FIXME:
	 *
	 * Up to that point drivers need to manage events themselves and can use
	 * even->base.list freely for that. Specifically they need to ensure
	 * that they don't send out page flip (or vblank) events for which the
	 * corresponding drm file has been closed already. The drm core
	 * unfortunately does not (yet) take care of that. Therefore drivers
	 * currently must clean up and release pending events in their
	 * ->preclose driver function.
	 *
	 * This callback is optional.
	 *
	 * NOTE:
	 *
	 * Very early versions of the KMS ABI mandated that the driver must
	 * block (but not reject) any rendering to the old framebuffer until the
	 * flip operation has completed and the old framebuffer is no longer
	 * visible. This requirement has been lifted, and userspace is instead
	 * expected to request delivery of an event and wait with recycling old
	 * buffers until such has been received.
	 *
	 * RETURNS:
	 *
	 * 0 on success or a negative error code on failure. Note that if a
	 * ->page_flip() operation is already pending the callback should return
	 * -EBUSY. Pageflips on a disabled CRTC (either by setting a NULL mode
	 * or just runtime disabled through DPMS respectively the new atomic
	 * "ACTIVE" state) should result in an -EINVAL error code.
547 548 549
	 */
	int (*page_flip)(struct drm_crtc *crtc,
			 struct drm_framebuffer *fb,
550 551
			 struct drm_pending_vblank_event *event,
			 uint32_t flags);
P
Paulo Zanoni 已提交
552

553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568
	/**
	 * @set_property:
	 *
	 * This is the legacy entry point to update a property attached to the
	 * CRTC.
	 *
	 * Drivers implementing atomic modeset should use
	 * drm_atomic_helper_crtc_set_property() to implement this hook.
	 *
	 * This callback is optional if the driver does not support any legacy
	 * driver-private properties.
	 *
	 * RETURNS:
	 *
	 * 0 on success or a negative error code on failure.
	 */
P
Paulo Zanoni 已提交
569 570
	int (*set_property)(struct drm_crtc *crtc,
			    struct drm_property *property, uint64_t val);
571

572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
	/**
	 * @atomic_duplicate_state:
	 *
	 * Duplicate the current atomic state for this CRTC and return it.
	 * The core and helpers gurantee that any atomic state duplicated with
	 * this hook and still owned by the caller (i.e. not transferred to the
	 * driver by calling ->atomic_commit() from struct
	 * &drm_mode_config_funcs) will be cleaned up by calling the
	 * @atomic_destroy_state hook in this structure.
	 *
	 * Atomic drivers which don't subclass struct &drm_crtc should use
	 * drm_atomic_helper_crtc_duplicate_state(). Drivers that subclass the
	 * state structure to extend it with driver-private state should use
	 * __drm_atomic_helper_crtc_duplicate_state() to make sure shared state is
	 * duplicated in a consistent fashion across drivers.
	 *
	 * It is an error to call this hook before crtc->state has been
	 * initialized correctly.
	 *
	 * NOTE:
	 *
	 * If the duplicate state references refcounted resources this hook must
	 * acquire a reference for each of them. The driver must release these
	 * references again in @atomic_destroy_state.
	 *
	 * RETURNS:
	 *
	 * Duplicated atomic state or NULL when the allocation failed.
	 */
601
	struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc);
602 603 604 605 606 607 608

	/**
	 * @atomic_destroy_state:
	 *
	 * Destroy a state duplicated with @atomic_duplicate_state and release
	 * or unreference all resources it references
	 */
609
	void (*atomic_destroy_state)(struct drm_crtc *crtc,
D
Daniel Vetter 已提交
610
				     struct drm_crtc_state *state);
611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653

	/**
	 * @atomic_set_property:
	 *
	 * Decode a driver-private property value and store the decoded value
	 * into the passed-in state structure. Since the atomic core decodes all
	 * standardized properties (even for extensions beyond the core set of
	 * properties which might not be implemented by all drivers) this
	 * requires drivers to subclass the state structure.
	 *
	 * Such driver-private properties should really only be implemented for
	 * truly hardware/vendor specific state. Instead it is preferred to
	 * standardize atomic extension and decode the properties used to expose
	 * such an extension in the core.
	 *
	 * Do not call this function directly, use
	 * drm_atomic_crtc_set_property() instead.
	 *
	 * This callback is optional if the driver does not support any
	 * driver-private atomic properties.
	 *
	 * NOTE:
	 *
	 * This function is called in the state assembly phase of atomic
	 * modesets, which can be aborted for any reason (including on
	 * userspace's request to just check whether a configuration would be
	 * possible). Drivers MUST NOT touch any persistent state (hardware or
	 * software) or data structures except the passed in @state parameter.
	 *
	 * Also since userspace controls in which order properties are set this
	 * function must not do any input validation (since the state update is
	 * incomplete and hence likely inconsistent). Instead any such input
	 * validation must be done in the various atomic_check callbacks.
	 *
	 * RETURNS:
	 *
	 * 0 if the property has been found, -EINVAL if the property isn't
	 * implemented by the driver (which should never happen, the core only
	 * asks for properties attached to this CRTC). No other validation is
	 * allowed by the driver. The core already checks that the property
	 * value is within the range (integer, valid enum value, ...) the driver
	 * set when registering the property.
	 */
654 655 656 657
	int (*atomic_set_property)(struct drm_crtc *crtc,
				   struct drm_crtc_state *state,
				   struct drm_property *property,
				   uint64_t val);
658 659 660 661
	/**
	 * @atomic_get_property:
	 *
	 * Reads out the decoded driver-private property. This is used to
662
	 * implement the GETCRTC IOCTL.
663 664 665 666 667 668 669 670 671 672 673 674 675
	 *
	 * Do not call this function directly, use
	 * drm_atomic_crtc_get_property() instead.
	 *
	 * This callback is optional if the driver does not support any
	 * driver-private atomic properties.
	 *
	 * RETURNS:
	 *
	 * 0 on success, -EINVAL if the property isn't implemented by the
	 * driver (which should never happen, the core only asks for
	 * properties attached to this CRTC).
	 */
R
Rob Clark 已提交
676 677 678 679
	int (*atomic_get_property)(struct drm_crtc *crtc,
				   const struct drm_crtc_state *state,
				   struct drm_property *property,
				   uint64_t *val);
D
Dave Airlie 已提交
680 681 682
};

/**
683
 * struct drm_crtc - central CRTC control structure
684
 * @dev: parent DRM device
D
Daniel Vetter 已提交
685
 * @port: OF node used by drm_of_find_possible_crtcs()
686
 * @head: list management
687
 * @mutex: per-CRTC locking
688
 * @base: base KMS object for ID tracking etc.
689 690
 * @primary: primary plane for this CRTC
 * @cursor: cursor plane for this CRTC
D
Daniel Vetter 已提交
691 692
 * @cursor_x: current x position of the cursor, used for universal cursor planes
 * @cursor_y: current y position of the cursor, used for universal cursor planes
D
Dave Airlie 已提交
693
 * @enabled: is this CRTC enabled?
694 695
 * @mode: current mode timings
 * @hwmode: mode timings as programmed to hw regs
D
Dave Airlie 已提交
696 697 698
 * @x: x position on screen
 * @y: y position on screen
 * @funcs: CRTC control functions
699 700 701
 * @gamma_size: size of gamma ramp
 * @gamma_store: gamma ramp values
 * @helper_private: mid-layer private data
P
Paulo Zanoni 已提交
702
 * @properties: property tracking for this CRTC
703
 * @state: current atomic state for this CRTC
D
Daniel Vetter 已提交
704
 * @acquire_ctx: per-CRTC implicit acquire context used by atomic drivers for
705
 * 	legacy IOCTLs
D
Dave Airlie 已提交
706 707 708 709 710 711
 *
 * Each CRTC may have one or more connectors associated with it.  This structure
 * allows the CRTC to be controlled.
 */
struct drm_crtc {
	struct drm_device *dev;
712
	struct device_node *port;
D
Dave Airlie 已提交
713 714
	struct list_head head;

715
	/*
D
Daniel Vetter 已提交
716 717 718 719 720 721
	 * crtc mutex
	 *
	 * This provides a read lock for the overall crtc state (mode, dpms
	 * state, ...) and a write lock for everything which can be update
	 * without a full modeset (fb, cursor data, ...)
	 */
722
	struct drm_modeset_lock mutex;
D
Daniel Vetter 已提交
723

D
Dave Airlie 已提交
724 725
	struct drm_mode_object base;

726 727 728 729
	/* primary and cursor planes for CRTC */
	struct drm_plane *primary;
	struct drm_plane *cursor;

730 731 732 733
	/* position of cursor plane on crtc */
	int cursor_x;
	int cursor_y;

D
Dave Airlie 已提交
734 735
	bool enabled;

736
	/* Requested mode from modesetting. */
D
Dave Airlie 已提交
737 738
	struct drm_display_mode mode;

739 740 741 742 743
	/* Programmed mode in hw, after adjustments for encoders,
	 * crtc, panel scaling etc. Needed for timestamping etc.
	 */
	struct drm_display_mode hwmode;

D
Dave Airlie 已提交
744 745 746 747 748 749 750 751
	int x, y;
	const struct drm_crtc_funcs *funcs;

	/* CRTC gamma size for reporting to userspace */
	uint32_t gamma_size;
	uint16_t *gamma_store;

	/* if you are using the helper */
752
	const struct drm_crtc_helper_funcs *helper_private;
P
Paulo Zanoni 已提交
753 754

	struct drm_object_properties properties;
755

756 757
	struct drm_crtc_state *state;

758
	/*
759
	 * For legacy crtc IOCTLs so that atomic drivers can get at the locking
760 761 762
	 * acquire context.
	 */
	struct drm_modeset_acquire_ctx *acquire_ctx;
D
Dave Airlie 已提交
763 764
};

765 766
/**
 * struct drm_connector_state - mutable connector state
767
 * @connector: backpointer to the connector
D
Daniel Vetter 已提交
768
 * @crtc: CRTC to connect connector to, NULL if disabled
769
 * @best_encoder: can be used by helpers and drivers to select the encoder
770 771 772
 * @state: backpointer to global drm_atomic_state
 */
struct drm_connector_state {
773 774
	struct drm_connector *connector;

775
	struct drm_crtc *crtc;  /* do not write directly, use drm_atomic_set_crtc_for_connector() */
776

777 778
	struct drm_encoder *best_encoder;

779 780
	struct drm_atomic_state *state;
};
D
Dave Airlie 已提交
781 782

/**
783
 * struct drm_connector_funcs - control connectors on a given device
784
 *
D
Dave Airlie 已提交
785 786 787 788 789
 * Each CRTC may have one or more connectors attached to it.  The functions
 * below allow the core DRM code to control connectors, enumerate available modes,
 * etc.
 */
struct drm_connector_funcs {
D
Daniel Vetter 已提交
790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
	/**
	 * @dpms:
	 *
	 * Legacy entry point to set the per-connector DPMS state. Legacy DPMS
	 * is exposed as a standard property on the connector, but diverted to
	 * this callback in the drm core. Note that atomic drivers don't
	 * implement the 4 level DPMS support on the connector any more, but
	 * instead only have an on/off "ACTIVE" property on the CRTC object.
	 *
	 * Drivers implementing atomic modeset should use
	 * drm_atomic_helper_connector_dpms() to implement this hook.
	 *
	 * RETURNS:
	 *
	 * 0 on success or a negative error code on failure.
	 */
806
	int (*dpms)(struct drm_connector *connector, int mode);
807 808 809 810 811 812 813 814 815 816 817

	/**
	 * @reset:
	 *
	 * Reset connector hardware and software state to off. This function isn't
	 * called by the core directly, only through drm_mode_config_reset().
	 * It's not a helper hook only for historical reasons.
	 *
	 * Atomic drivers can use drm_atomic_helper_connector_reset() to reset
	 * atomic state using this hook.
	 */
818
	void (*reset)(struct drm_connector *connector);
819

D
Daniel Vetter 已提交
820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836
	/**
	 * @detect:
	 *
	 * Check to see if anything is attached to the connector. The parameter
	 * force is set to false whilst polling, true when checking the
	 * connector due to a user request. force can be used by the driver to
	 * avoid expensive, destructive operations during automated probing.
	 *
	 * FIXME:
	 *
	 * Note that this hook is only called by the probe helper. It's not in
	 * the helper library vtable purely for historical reasons. The only DRM
	 * core	entry point to probe connector state is @fill_modes.
	 *
	 * RETURNS:
	 *
	 * drm_connector_status indicating the connector's status.
837
	 */
838
	enum drm_connector_status (*detect)(struct drm_connector *connector,
839
					    bool force);
D
Daniel Vetter 已提交
840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880

	/**
	 * @force:
	 *
	 * This function is called to update internal encoder state when the
	 * connector is forced to a certain state by userspace, either through
	 * the sysfs interfaces or on the kernel cmdline. In that case the
	 * @detect callback isn't called.
	 *
	 * FIXME:
	 *
	 * Note that this hook is only called by the probe helper. It's not in
	 * the helper library vtable purely for historical reasons. The only DRM
	 * core	entry point to probe connector state is @fill_modes.
	 */
	void (*force)(struct drm_connector *connector);

	/**
	 * @fill_modes:
	 *
	 * Entry point for output detection and basic mode validation. The
	 * driver should reprobe the output if needed (e.g. when hotplug
	 * handling is unreliable), add all detected modes to connector->modes
	 * and filter out any the device can't support in any configuration. It
	 * also needs to filter out any modes wider or higher than the
	 * parameters max_width and max_height indicate.
	 *
	 * The drivers must also prune any modes no longer valid from
	 * connector->modes. Furthermore it must update connector->status and
	 * connector->edid.  If no EDID has been received for this output
	 * connector->edid must be NULL.
	 *
	 * Drivers using the probe helpers should use
	 * drm_helper_probe_single_connector_modes() or
	 * drm_helper_probe_single_connector_modes_nomerge() to implement this
	 * function.
	 *
	 * RETURNS:
	 *
	 * The number of modes detected and filled into connector->modes.
	 */
J
Jesse Barnes 已提交
881
	int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height);
882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898

	/**
	 * @set_property:
	 *
	 * This is the legacy entry point to update a property attached to the
	 * connector.
	 *
	 * Drivers implementing atomic modeset should use
	 * drm_atomic_helper_connector_set_property() to implement this hook.
	 *
	 * This callback is optional if the driver does not support any legacy
	 * driver-private properties.
	 *
	 * RETURNS:
	 *
	 * 0 on success or a negative error code on failure.
	 */
D
Dave Airlie 已提交
899 900
	int (*set_property)(struct drm_connector *connector, struct drm_property *property,
			     uint64_t val);
901 902 903 904 905 906 907 908 909

	/**
	 * @destroy:
	 *
	 * Clean up connector resources. This is called at driver unload time
	 * through drm_mode_config_cleanup(). It can also be called at runtime
	 * when a connector is being hot-unplugged for drivers that support
	 * connector hotplugging (e.g. DisplayPort MST).
	 */
D
Dave Airlie 已提交
910
	void (*destroy)(struct drm_connector *connector);
911

912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940
	/**
	 * @atomic_duplicate_state:
	 *
	 * Duplicate the current atomic state for this connector and return it.
	 * The core and helpers gurantee that any atomic state duplicated with
	 * this hook and still owned by the caller (i.e. not transferred to the
	 * driver by calling ->atomic_commit() from struct
	 * &drm_mode_config_funcs) will be cleaned up by calling the
	 * @atomic_destroy_state hook in this structure.
	 *
	 * Atomic drivers which don't subclass struct &drm_connector_state should use
	 * drm_atomic_helper_connector_duplicate_state(). Drivers that subclass the
	 * state structure to extend it with driver-private state should use
	 * __drm_atomic_helper_connector_duplicate_state() to make sure shared state is
	 * duplicated in a consistent fashion across drivers.
	 *
	 * It is an error to call this hook before connector->state has been
	 * initialized correctly.
	 *
	 * NOTE:
	 *
	 * If the duplicate state references refcounted resources this hook must
	 * acquire a reference for each of them. The driver must release these
	 * references again in @atomic_destroy_state.
	 *
	 * RETURNS:
	 *
	 * Duplicated atomic state or NULL when the allocation failed.
	 */
941
	struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector);
942 943 944 945 946 947 948

	/**
	 * @atomic_destroy_state:
	 *
	 * Destroy a state duplicated with @atomic_duplicate_state and release
	 * or unreference all resources it references
	 */
949
	void (*atomic_destroy_state)(struct drm_connector *connector,
D
Daniel Vetter 已提交
950
				     struct drm_connector_state *state);
951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993

	/**
	 * @atomic_set_property:
	 *
	 * Decode a driver-private property value and store the decoded value
	 * into the passed-in state structure. Since the atomic core decodes all
	 * standardized properties (even for extensions beyond the core set of
	 * properties which might not be implemented by all drivers) this
	 * requires drivers to subclass the state structure.
	 *
	 * Such driver-private properties should really only be implemented for
	 * truly hardware/vendor specific state. Instead it is preferred to
	 * standardize atomic extension and decode the properties used to expose
	 * such an extension in the core.
	 *
	 * Do not call this function directly, use
	 * drm_atomic_connector_set_property() instead.
	 *
	 * This callback is optional if the driver does not support any
	 * driver-private atomic properties.
	 *
	 * NOTE:
	 *
	 * This function is called in the state assembly phase of atomic
	 * modesets, which can be aborted for any reason (including on
	 * userspace's request to just check whether a configuration would be
	 * possible). Drivers MUST NOT touch any persistent state (hardware or
	 * software) or data structures except the passed in @state parameter.
	 *
	 * Also since userspace controls in which order properties are set this
	 * function must not do any input validation (since the state update is
	 * incomplete and hence likely inconsistent). Instead any such input
	 * validation must be done in the various atomic_check callbacks.
	 *
	 * RETURNS:
	 *
	 * 0 if the property has been found, -EINVAL if the property isn't
	 * implemented by the driver (which shouldn't ever happen, the core only
	 * asks for properties attached to this connector). No other validation
	 * is allowed by the driver. The core already checks that the property
	 * value is within the range (integer, valid enum value, ...) the driver
	 * set when registering the property.
	 */
994 995 996 997
	int (*atomic_set_property)(struct drm_connector *connector,
				   struct drm_connector_state *state,
				   struct drm_property *property,
				   uint64_t val);
998 999 1000 1001 1002

	/**
	 * @atomic_get_property:
	 *
	 * Reads out the decoded driver-private property. This is used to
1003
	 * implement the GETCONNECTOR IOCTL.
1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016
	 *
	 * Do not call this function directly, use
	 * drm_atomic_connector_get_property() instead.
	 *
	 * This callback is optional if the driver does not support any
	 * driver-private atomic properties.
	 *
	 * RETURNS:
	 *
	 * 0 on success, -EINVAL if the property isn't implemented by the
	 * driver (which shouldn't ever happen, the core only asks for
	 * properties attached to this connector).
	 */
R
Rob Clark 已提交
1017 1018 1019 1020
	int (*atomic_get_property)(struct drm_connector *connector,
				   const struct drm_connector_state *state,
				   struct drm_property *property,
				   uint64_t *val);
D
Dave Airlie 已提交
1021 1022
};

1023
/**
1024
 * struct drm_encoder_funcs - encoder controls
1025 1026 1027
 *
 * Encoders sit between CRTCs and connectors.
 */
D
Dave Airlie 已提交
1028
struct drm_encoder_funcs {
1029 1030 1031 1032 1033 1034 1035
	/**
	 * @reset:
	 *
	 * Reset encoder hardware and software state to off. This function isn't
	 * called by the core directly, only through drm_mode_config_reset().
	 * It's not a helper hook only for historical reasons.
	 */
1036
	void (*reset)(struct drm_encoder *encoder);
1037 1038 1039 1040 1041 1042 1043 1044

	/**
	 * @destroy:
	 *
	 * Clean up encoder resources. This is only called at driver unload time
	 * through drm_mode_config_cleanup() since an encoder cannot be
	 * hotplugged in DRM.
	 */
D
Dave Airlie 已提交
1045 1046 1047
	void (*destroy)(struct drm_encoder *encoder);
};

1048
#define DRM_CONNECTOR_MAX_ENCODER 3
D
Dave Airlie 已提交
1049 1050

/**
1051
 * struct drm_encoder - central DRM encoder structure
J
Jesse Barnes 已提交
1052 1053 1054
 * @dev: parent DRM device
 * @head: list management
 * @base: base KMS object
1055
 * @name: encoder name
J
Jesse Barnes 已提交
1056 1057 1058 1059
 * @encoder_type: one of the %DRM_MODE_ENCODER_<foo> types in drm_mode.h
 * @possible_crtcs: bitmask of potential CRTC bindings
 * @possible_clones: bitmask of potential sibling encoders for cloning
 * @crtc: currently bound CRTC
S
Sean Paul 已提交
1060
 * @bridge: bridge associated to the encoder
J
Jesse Barnes 已提交
1061 1062 1063 1064 1065
 * @funcs: control functions
 * @helper_private: mid-layer private data
 *
 * CRTCs drive pixels to encoders, which convert them into signals
 * appropriate for a given connector or set of connectors.
D
Dave Airlie 已提交
1066 1067 1068 1069 1070 1071
 */
struct drm_encoder {
	struct drm_device *dev;
	struct list_head head;

	struct drm_mode_object base;
1072
	char *name;
D
Dave Airlie 已提交
1073 1074 1075 1076 1077
	int encoder_type;
	uint32_t possible_crtcs;
	uint32_t possible_clones;

	struct drm_crtc *crtc;
S
Sean Paul 已提交
1078
	struct drm_bridge *bridge;
D
Dave Airlie 已提交
1079
	const struct drm_encoder_funcs *funcs;
1080
	const struct drm_encoder_helper_funcs *helper_private;
D
Dave Airlie 已提交
1081 1082
};

1083 1084 1085 1086 1087 1088 1089 1090 1091
/* should we poll this connector for connects and disconnects */
/* hot plug detectable */
#define DRM_CONNECTOR_POLL_HPD (1 << 0)
/* poll for connections */
#define DRM_CONNECTOR_POLL_CONNECT (1 << 1)
/* can cleanly poll for disconnections without flickering the screen */
/* DACs should rarely do this without a lot of testing */
#define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2)

1092 1093
#define MAX_ELD_BYTES	128

D
Dave Airlie 已提交
1094
/**
1095
 * struct drm_connector - central DRM connector control structure
1096 1097 1098 1099 1100
 * @dev: parent DRM device
 * @kdev: kernel device for sysfs attributes
 * @attr: sysfs attributes
 * @head: list management
 * @base: base KMS object
1101
 * @name: connector name
1102 1103
 * @connector_type: one of the %DRM_MODE_CONNECTOR_<foo> types from drm_mode.h
 * @connector_type_id: index into connector type enum
D
Dave Airlie 已提交
1104 1105
 * @interlace_allowed: can this connector handle interlaced modes?
 * @doublescan_allowed: can this connector handle doublescan?
D
Daniel Vetter 已提交
1106
 * @stereo_allowed: can this connector handle stereo modes?
1107 1108 1109 1110
 * @modes: modes available on this connector (from fill_modes() + user)
 * @status: one of the drm_connector_status enums (connected, not, or unknown)
 * @probed_modes: list of modes derived directly from the display
 * @display_info: information about attached display (e.g. from EDID)
D
Dave Airlie 已提交
1111
 * @funcs: connector control functions
1112
 * @edid_blob_ptr: DRM property containing EDID if present
1113
 * @properties: property tracking for this connector
D
Daniel Vetter 已提交
1114
 * @path_blob_ptr: DRM blob property data for the DP MST path property
1115 1116 1117
 * @polled: a %DRM_CONNECTOR_POLL_<foo> value for core driven polling
 * @dpms: current dpms state
 * @helper_private: mid-layer private data
D
Daniel Vetter 已提交
1118
 * @cmdline_mode: mode line parsed from the kernel cmdline for this connector
1119
 * @force: a %DRM_FORCE_<foo> state for forced mode sets
D
Daniel Vetter 已提交
1120
 * @override_edid: has the EDID been overwritten through debugfs for testing?
1121 1122 1123 1124 1125 1126 1127 1128 1129
 * @encoder_ids: valid encoders for this connector
 * @encoder: encoder driving this connector, if any
 * @eld: EDID-like data, if present
 * @dvi_dual: dual link DVI, if found
 * @max_tmds_clock: max clock rate, if found
 * @latency_present: AV delay info from ELD, if found
 * @video_latency: video latency info from ELD, if found
 * @audio_latency: audio latency info from ELD, if found
 * @null_edid_counter: track sinks that give us all zeros for the EDID
D
Daniel Vetter 已提交
1130
 * @bad_edid_counter: track sinks that give us an EDID with invalid checksum
1131
 * @edid_corrupt: indicates whether the last read EDID was corrupt
D
Daniel Vetter 已提交
1132
 * @debugfs_entry: debugfs directory for this connector
1133
 * @state: current atomic state for this connector
1134 1135 1136 1137 1138 1139 1140 1141 1142
 * @has_tile: is this connector connected to a tiled monitor
 * @tile_group: tile group for the connected monitor
 * @tile_is_single_monitor: whether the tile is one monitor housing
 * @num_h_tile: number of horizontal tiles in the tile group
 * @num_v_tile: number of vertical tiles in the tile group
 * @tile_h_loc: horizontal location of this tile
 * @tile_v_loc: vertical location of this tile
 * @tile_h_size: horizontal size of this tile.
 * @tile_v_size: vertical size of this tile.
D
Dave Airlie 已提交
1143 1144 1145 1146 1147 1148 1149 1150
 *
 * Each connector may be connected to one or more CRTCs, or may be clonable by
 * another connector if they can share a CRTC.  Each connector also has a specific
 * position in the broader display (referred to as a 'screen' though it could
 * span multiple monitors).
 */
struct drm_connector {
	struct drm_device *dev;
1151
	struct device *kdev;
D
Dave Airlie 已提交
1152 1153 1154 1155 1156
	struct device_attribute *attr;
	struct list_head head;

	struct drm_mode_object base;

1157
	char *name;
D
Dave Airlie 已提交
1158 1159 1160 1161
	int connector_type;
	int connector_type_id;
	bool interlace_allowed;
	bool doublescan_allowed;
1162
	bool stereo_allowed;
D
Dave Airlie 已提交
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
	struct list_head modes; /* list of modes on this connector */

	enum drm_connector_status status;

	/* these are modes added by probing with DDC or the BIOS */
	struct list_head probed_modes;

	struct drm_display_info display_info;
	const struct drm_connector_funcs *funcs;

	struct drm_property_blob *edid_blob_ptr;
1174
	struct drm_object_properties properties;
D
Dave Airlie 已提交
1175

D
Dave Airlie 已提交
1176 1177
	struct drm_property_blob *path_blob_ptr;

1178 1179
	struct drm_property_blob *tile_blob_ptr;

1180 1181
	uint8_t polled; /* DRM_CONNECTOR_POLL_* */

1182 1183 1184
	/* requested DPMS state */
	int dpms;

1185
	const struct drm_connector_helper_funcs *helper_private;
D
Dave Airlie 已提交
1186

1187
	/* forced on connector */
1188
	struct drm_cmdline_mode cmdline_mode;
1189
	enum drm_connector_force force;
1190
	bool override_edid;
D
Dave Airlie 已提交
1191 1192
	uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER];
	struct drm_encoder *encoder; /* currently active encoder */
1193

1194 1195 1196 1197 1198 1199 1200
	/* EDID bits */
	uint8_t eld[MAX_ELD_BYTES];
	bool dvi_dual;
	int max_tmds_clock;	/* in MHz */
	bool latency_present[2];
	int video_latency[2];	/* [0]: progressive, [1]: interlaced */
	int audio_latency[2];
1201
	int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */
1202
	unsigned bad_edid_counter;
1203

1204 1205 1206 1207 1208
	/* Flag for raw EDID header corruption - used in Displayport
	 * compliance testing - * Displayport Link CTS Core 1.2 rev1.1 4.2.2.6
	 */
	bool edid_corrupt;

1209
	struct dentry *debugfs_entry;
1210 1211

	struct drm_connector_state *state;
1212 1213 1214 1215 1216 1217 1218 1219 1220

	/* DisplayID bits */
	bool has_tile;
	struct drm_tile_group *tile_group;
	bool tile_is_single_monitor;

	uint8_t num_h_tile, num_v_tile;
	uint8_t tile_h_loc, tile_v_loc;
	uint16_t tile_h_size, tile_v_size;
1221 1222 1223 1224
};

/**
 * struct drm_plane_state - mutable plane state
1225
 * @plane: backpointer to the plane
1226
 * @crtc: currently bound CRTC, NULL if disabled
D
Daniel Vetter 已提交
1227
 * @fb: currently bound framebuffer
1228
 * @fence: optional fence to wait for before scanning out @fb
1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241
 * @crtc_x: left position of visible portion of plane on crtc
 * @crtc_y: upper position of visible portion of plane on crtc
 * @crtc_w: width of visible portion of plane on crtc
 * @crtc_h: height of visible portion of plane on crtc
 * @src_x: left position of visible portion of plane within
 *	plane (in 16.16)
 * @src_y: upper position of visible portion of plane within
 *	plane (in 16.16)
 * @src_w: width of visible portion of plane (in 16.16)
 * @src_h: height of visible portion of plane (in 16.16)
 * @state: backpointer to global drm_atomic_state
 */
struct drm_plane_state {
1242 1243
	struct drm_plane *plane;

1244 1245
	struct drm_crtc *crtc;   /* do not write directly, use drm_atomic_set_crtc_for_plane() */
	struct drm_framebuffer *fb;  /* do not write directly, use drm_atomic_set_fb_for_plane() */
1246
	struct fence *fence;
1247 1248 1249 1250 1251 1252 1253 1254 1255

	/* Signed dest location allows it to be partially off screen */
	int32_t crtc_x, crtc_y;
	uint32_t crtc_w, crtc_h;

	/* Source values are 16.16 fixed point */
	uint32_t src_x, src_y;
	uint32_t src_h, src_w;

1256 1257 1258
	/* Plane rotation */
	unsigned int rotation;

1259
	struct drm_atomic_state *state;
D
Dave Airlie 已提交
1260 1261
};

1262

J
Jesse Barnes 已提交
1263
/**
1264
 * struct drm_plane_funcs - driver plane control functions
J
Jesse Barnes 已提交
1265 1266
 */
struct drm_plane_funcs {
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292
	/**
	 * @update_plane:
	 *
	 * This is the legacy entry point to enable and configure the plane for
	 * the given CRTC and framebuffer. It is never called to disable the
	 * plane, i.e. the passed-in crtc and fb paramters are never NULL.
	 *
	 * The source rectangle in frame buffer memory coordinates is given by
	 * the src_x, src_y, src_w and src_h parameters (as 16.16 fixed point
	 * values). Devices that don't support subpixel plane coordinates can
	 * ignore the fractional part.
	 *
	 * The destination rectangle in CRTC coordinates is given by the
	 * crtc_x, crtc_y, crtc_w and crtc_h parameters (as integer values).
	 * Devices scale the source rectangle to the destination rectangle. If
	 * scaling is not supported, and the source rectangle size doesn't match
	 * the destination rectangle size, the driver must return a
	 * -<errorname>EINVAL</errorname> error.
	 *
	 * Drivers implementing atomic modeset should use
	 * drm_atomic_helper_update_plane() to implement this hook.
	 *
	 * RETURNS:
	 *
	 * 0 on success or a negative error code on failure.
	 */
J
Jesse Barnes 已提交
1293 1294 1295 1296 1297 1298
	int (*update_plane)(struct drm_plane *plane,
			    struct drm_crtc *crtc, struct drm_framebuffer *fb,
			    int crtc_x, int crtc_y,
			    unsigned int crtc_w, unsigned int crtc_h,
			    uint32_t src_x, uint32_t src_y,
			    uint32_t src_w, uint32_t src_h);
1299 1300 1301 1302 1303

	/**
	 * @disable_plane:
	 *
	 * This is the legacy entry point to disable the plane. The DRM core
1304
	 * calls this method in response to a DRM_IOCTL_MODE_SETPLANE IOCTL call
1305 1306 1307 1308 1309 1310 1311 1312 1313 1314
	 * with the frame buffer ID set to 0.  Disabled planes must not be
	 * processed by the CRTC.
	 *
	 * Drivers implementing atomic modeset should use
	 * drm_atomic_helper_disable_plane() to implement this hook.
	 *
	 * RETURNS:
	 *
	 * 0 on success or a negative error code on failure.
	 */
J
Jesse Barnes 已提交
1315
	int (*disable_plane)(struct drm_plane *plane);
1316 1317 1318 1319 1320 1321 1322 1323

	/**
	 * @destroy:
	 *
	 * Clean up plane resources. This is only called at driver unload time
	 * through drm_mode_config_cleanup() since a plane cannot be hotplugged
	 * in DRM.
	 */
J
Jesse Barnes 已提交
1324
	void (*destroy)(struct drm_plane *plane);
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335

	/**
	 * @reset:
	 *
	 * Reset plane hardware and software state to off. This function isn't
	 * called by the core directly, only through drm_mode_config_reset().
	 * It's not a helper hook only for historical reasons.
	 *
	 * Atomic drivers can use drm_atomic_helper_plane_reset() to reset
	 * atomic state using this hook.
	 */
D
Daniel Vetter 已提交
1336
	void (*reset)(struct drm_plane *plane);
R
Rob Clark 已提交
1337

1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
	/**
	 * @set_property:
	 *
	 * This is the legacy entry point to update a property attached to the
	 * plane.
	 *
	 * Drivers implementing atomic modeset should use
	 * drm_atomic_helper_plane_set_property() to implement this hook.
	 *
	 * This callback is optional if the driver does not support any legacy
	 * driver-private properties.
	 *
	 * RETURNS:
	 *
	 * 0 on success or a negative error code on failure.
	 */
R
Rob Clark 已提交
1354 1355
	int (*set_property)(struct drm_plane *plane,
			    struct drm_property *property, uint64_t val);
1356

1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385
	/**
	 * @atomic_duplicate_state:
	 *
	 * Duplicate the current atomic state for this plane and return it.
	 * The core and helpers gurantee that any atomic state duplicated with
	 * this hook and still owned by the caller (i.e. not transferred to the
	 * driver by calling ->atomic_commit() from struct
	 * &drm_mode_config_funcs) will be cleaned up by calling the
	 * @atomic_destroy_state hook in this structure.
	 *
	 * Atomic drivers which don't subclass struct &drm_plane_state should use
	 * drm_atomic_helper_plane_duplicate_state(). Drivers that subclass the
	 * state structure to extend it with driver-private state should use
	 * __drm_atomic_helper_plane_duplicate_state() to make sure shared state is
	 * duplicated in a consistent fashion across drivers.
	 *
	 * It is an error to call this hook before plane->state has been
	 * initialized correctly.
	 *
	 * NOTE:
	 *
	 * If the duplicate state references refcounted resources this hook must
	 * acquire a reference for each of them. The driver must release these
	 * references again in @atomic_destroy_state.
	 *
	 * RETURNS:
	 *
	 * Duplicated atomic state or NULL when the allocation failed.
	 */
1386
	struct drm_plane_state *(*atomic_duplicate_state)(struct drm_plane *plane);
1387 1388 1389 1390 1391 1392 1393

	/**
	 * @atomic_destroy_state:
	 *
	 * Destroy a state duplicated with @atomic_duplicate_state and release
	 * or unreference all resources it references
	 */
1394
	void (*atomic_destroy_state)(struct drm_plane *plane,
D
Daniel Vetter 已提交
1395
				     struct drm_plane_state *state);
1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438

	/**
	 * @atomic_set_property:
	 *
	 * Decode a driver-private property value and store the decoded value
	 * into the passed-in state structure. Since the atomic core decodes all
	 * standardized properties (even for extensions beyond the core set of
	 * properties which might not be implemented by all drivers) this
	 * requires drivers to subclass the state structure.
	 *
	 * Such driver-private properties should really only be implemented for
	 * truly hardware/vendor specific state. Instead it is preferred to
	 * standardize atomic extension and decode the properties used to expose
	 * such an extension in the core.
	 *
	 * Do not call this function directly, use
	 * drm_atomic_plane_set_property() instead.
	 *
	 * This callback is optional if the driver does not support any
	 * driver-private atomic properties.
	 *
	 * NOTE:
	 *
	 * This function is called in the state assembly phase of atomic
	 * modesets, which can be aborted for any reason (including on
	 * userspace's request to just check whether a configuration would be
	 * possible). Drivers MUST NOT touch any persistent state (hardware or
	 * software) or data structures except the passed in @state parameter.
	 *
	 * Also since userspace controls in which order properties are set this
	 * function must not do any input validation (since the state update is
	 * incomplete and hence likely inconsistent). Instead any such input
	 * validation must be done in the various atomic_check callbacks.
	 *
	 * RETURNS:
	 *
	 * 0 if the property has been found, -EINVAL if the property isn't
	 * implemented by the driver (which shouldn't ever happen, the core only
	 * asks for properties attached to this plane). No other validation is
	 * allowed by the driver. The core already checks that the property
	 * value is within the range (integer, valid enum value, ...) the driver
	 * set when registering the property.
	 */
1439 1440 1441 1442
	int (*atomic_set_property)(struct drm_plane *plane,
				   struct drm_plane_state *state,
				   struct drm_property *property,
				   uint64_t val);
1443 1444 1445 1446 1447

	/**
	 * @atomic_get_property:
	 *
	 * Reads out the decoded driver-private property. This is used to
1448
	 * implement the GETPLANE IOCTL.
1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461
	 *
	 * Do not call this function directly, use
	 * drm_atomic_plane_get_property() instead.
	 *
	 * This callback is optional if the driver does not support any
	 * driver-private atomic properties.
	 *
	 * RETURNS:
	 *
	 * 0 on success, -EINVAL if the property isn't implemented by the
	 * driver (which should never happen, the core only asks for
	 * properties attached to this plane).
	 */
R
Rob Clark 已提交
1462 1463 1464 1465
	int (*atomic_get_property)(struct drm_plane *plane,
				   const struct drm_plane_state *state,
				   struct drm_property *property,
				   uint64_t *val);
J
Jesse Barnes 已提交
1466 1467
};

1468 1469 1470 1471 1472 1473
enum drm_plane_type {
	DRM_PLANE_TYPE_OVERLAY,
	DRM_PLANE_TYPE_PRIMARY,
	DRM_PLANE_TYPE_CURSOR,
};

1474

J
Jesse Barnes 已提交
1475
/**
1476
 * struct drm_plane - central DRM plane control structure
J
Jesse Barnes 已提交
1477 1478 1479 1480 1481 1482
 * @dev: DRM device this plane belongs to
 * @head: for list management
 * @base: base mode object
 * @possible_crtcs: pipes this plane can be bound to
 * @format_types: array of formats supported by this plane
 * @format_count: number of formats supported
1483
 * @format_default: driver hasn't supplied supported formats for the plane
J
Jesse Barnes 已提交
1484 1485
 * @crtc: currently bound CRTC
 * @fb: currently bound fb
D
Daniel Vetter 已提交
1486 1487
 * @old_fb: Temporary tracking of the old fb while a modeset is ongoing. Used by
 * 	drm_mode_set_config_internal() to implement correct refcounting.
J
Jesse Barnes 已提交
1488
 * @funcs: helper functions
R
Rob Clark 已提交
1489
 * @properties: property tracking for this plane
1490
 * @type: type of plane (overlay, primary, cursor)
1491
 * @state: current atomic state for this plane
J
Jesse Barnes 已提交
1492 1493 1494 1495 1496
 */
struct drm_plane {
	struct drm_device *dev;
	struct list_head head;

D
Daniel Vetter 已提交
1497 1498
	struct drm_modeset_lock mutex;

J
Jesse Barnes 已提交
1499 1500 1501 1502
	struct drm_mode_object base;

	uint32_t possible_crtcs;
	uint32_t *format_types;
1503
	unsigned int format_count;
1504
	bool format_default;
J
Jesse Barnes 已提交
1505 1506 1507 1508

	struct drm_crtc *crtc;
	struct drm_framebuffer *fb;

1509 1510
	struct drm_framebuffer *old_fb;

J
Jesse Barnes 已提交
1511
	const struct drm_plane_funcs *funcs;
R
Rob Clark 已提交
1512 1513

	struct drm_object_properties properties;
1514 1515

	enum drm_plane_type type;
1516

1517
	const struct drm_plane_helper_funcs *helper_private;
D
Daniel Vetter 已提交
1518

1519
	struct drm_plane_state *state;
J
Jesse Barnes 已提交
1520 1521
};

S
Sean Paul 已提交
1522
/**
1523
 * struct drm_bridge_funcs - drm_bridge control functions
1524
 * @attach: Called during drm_bridge_attach
S
Sean Paul 已提交
1525 1526
 */
struct drm_bridge_funcs {
1527
	int (*attach)(struct drm_bridge *bridge);
D
Daniel Vetter 已提交
1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548

	/**
	 * @mode_fixup:
	 *
	 * This callback is used to validate and adjust a mode. The paramater
	 * mode is the display mode that should be fed to the next element in
	 * the display chain, either the final &drm_connector or the next
	 * &drm_bridge. The parameter adjusted_mode is the input mode the bridge
	 * requires. It can be modified by this callback and does not need to
	 * match mode.
	 *
	 * This is the only hook that allows a bridge to reject a modeset. If
	 * this function passes all other callbacks must succeed for this
	 * configuration.
	 *
	 * NOTE:
	 *
	 * This function is called in the check phase of atomic modesets, which
	 * can be aborted for any reason (including on userspace's request to
	 * just check whether a configuration would be possible). Drivers MUST
	 * NOT touch any persistent state (hardware or software) or data
1549
	 * structures except the passed in @state parameter.
D
Daniel Vetter 已提交
1550 1551 1552 1553 1554 1555
	 *
	 * RETURNS:
	 *
	 * True if an acceptable configuration is possible, false if the modeset
	 * operation should be rejected.
	 */
S
Sean Paul 已提交
1556 1557 1558
	bool (*mode_fixup)(struct drm_bridge *bridge,
			   const struct drm_display_mode *mode,
			   struct drm_display_mode *adjusted_mode);
D
Daniel Vetter 已提交
1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571
	/**
	 * @disable:
	 *
	 * This callback should disable the bridge. It is called right before
	 * the preceding element in the display pipe is disabled. If the
	 * preceding element is a bridge this means it's called before that
	 * bridge's ->disable() function. If the preceding element is a
	 * &drm_encoder it's called right before the encoder's ->disable(),
	 * ->prepare() or ->dpms() hook from struct &drm_encoder_helper_funcs.
	 *
	 * The bridge can assume that the display pipe (i.e. clocks and timing
	 * signals) feeding it is still running when this callback is called.
	 */
S
Sean Paul 已提交
1572
	void (*disable)(struct drm_bridge *bridge);
D
Daniel Vetter 已提交
1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587

	/**
	 * @post_disable:
	 *
	 * This callback should disable the bridge. It is called right after
	 * the preceding element in the display pipe is disabled. If the
	 * preceding element is a bridge this means it's called after that
	 * bridge's ->post_disable() function. If the preceding element is a
	 * &drm_encoder it's called right after the encoder's ->disable(),
	 * ->prepare() or ->dpms() hook from struct &drm_encoder_helper_funcs.
	 *
	 * The bridge must assume that the display pipe (i.e. clocks and timing
	 * singals) feeding it is no longer running when this callback is
	 * called.
	 */
S
Sean Paul 已提交
1588
	void (*post_disable)(struct drm_bridge *bridge);
D
Daniel Vetter 已提交
1589 1590 1591 1592 1593 1594 1595 1596 1597

	/**
	 * @mode_set:
	 *
	 * This callback should set the given mode on the bridge. It is called
	 * after the ->mode_set() callback for the preceding element in the
	 * display pipeline has been called already. The display pipe (i.e.
	 * clocks and timing signals) is off when this function is called.
	 */
S
Sean Paul 已提交
1598 1599 1600
	void (*mode_set)(struct drm_bridge *bridge,
			 struct drm_display_mode *mode,
			 struct drm_display_mode *adjusted_mode);
D
Daniel Vetter 已提交
1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
	/**
	 * @pre_enable:
	 *
	 * This callback should enable the bridge. It is called right before
	 * the preceding element in the display pipe is enabled. If the
	 * preceding element is a bridge this means it's called before that
	 * bridge's ->pre_enable() function. If the preceding element is a
	 * &drm_encoder it's called right before the encoder's ->enable(),
	 * ->commit() or ->dpms() hook from struct &drm_encoder_helper_funcs.
	 *
	 * The display pipe (i.e. clocks and timing signals) feeding this bridge
	 * will not yet be running when this callback is called. The bridge must
	 * not enable the display link feeding the next bridge in the chain (if
	 * there is one) when this callback is called.
	 */
S
Sean Paul 已提交
1616
	void (*pre_enable)(struct drm_bridge *bridge);
D
Daniel Vetter 已提交
1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632

	/**
	 * @enable:
	 *
	 * This callback should enable the bridge. It is called right after
	 * the preceding element in the display pipe is enabled. If the
	 * preceding element is a bridge this means it's called after that
	 * bridge's ->enable() function. If the preceding element is a
	 * &drm_encoder it's called right after the encoder's ->enable(),
	 * ->commit() or ->dpms() hook from struct &drm_encoder_helper_funcs.
	 *
	 * The bridge can assume that the display pipe (i.e. clocks and timing
	 * signals) feeding it is running when this callback is called. This
	 * callback must enable the display link feeding the next bridge in the
	 * chain if there is one.
	 */
S
Sean Paul 已提交
1633 1634 1635 1636
	void (*enable)(struct drm_bridge *bridge);
};

/**
1637
 * struct drm_bridge - central DRM bridge control structure
S
Sean Paul 已提交
1638
 * @dev: DRM device this bridge belongs to
1639 1640
 * @encoder: encoder to which this bridge is connected
 * @next: the next bridge in the encoder chain
1641 1642
 * @of_node: device node pointer to the bridge
 * @list: to keep track of all added bridges
S
Sean Paul 已提交
1643 1644 1645 1646 1647
 * @funcs: control functions
 * @driver_private: pointer to the bridge driver's internal context
 */
struct drm_bridge {
	struct drm_device *dev;
1648
	struct drm_encoder *encoder;
1649
	struct drm_bridge *next;
1650 1651 1652 1653
#ifdef CONFIG_OF
	struct device_node *of_node;
#endif
	struct list_head list;
S
Sean Paul 已提交
1654 1655 1656 1657 1658

	const struct drm_bridge_funcs *funcs;
	void *driver_private;
};

D
Daniel Vetter 已提交
1659
/**
R
Rob Clark 已提交
1660
 * struct drm_atomic_state - the global state object for atomic updates
D
Daniel Vetter 已提交
1661
 * @dev: parent DRM device
R
Rob Clark 已提交
1662
 * @allow_modeset: allow full modeset
1663
 * @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics
D
Daniel Vetter 已提交
1664 1665 1666 1667
 * @planes: pointer to array of plane pointers
 * @plane_states: pointer to array of plane states pointers
 * @crtcs: pointer to array of CRTC pointers
 * @crtc_states: pointer to array of CRTC states pointers
1668
 * @num_connector: size of the @connectors and @connector_states arrays
D
Daniel Vetter 已提交
1669 1670 1671 1672 1673 1674
 * @connectors: pointer to array of connector pointers
 * @connector_states: pointer to array of connector states pointers
 * @acquire_ctx: acquire context for this atomic modeset state update
 */
struct drm_atomic_state {
	struct drm_device *dev;
R
Rob Clark 已提交
1675
	bool allow_modeset : 1;
1676
	bool legacy_cursor_update : 1;
D
Daniel Vetter 已提交
1677 1678 1679 1680
	struct drm_plane **planes;
	struct drm_plane_state **plane_states;
	struct drm_crtc **crtcs;
	struct drm_crtc_state **crtc_states;
1681
	int num_connector;
D
Daniel Vetter 已提交
1682 1683 1684 1685 1686 1687 1688
	struct drm_connector **connectors;
	struct drm_connector_state **connector_states;

	struct drm_modeset_acquire_ctx *acquire_ctx;
};


D
Dave Airlie 已提交
1689
/**
1690
 * struct drm_mode_set - new values for a CRTC config change
1691 1692 1693 1694 1695 1696 1697
 * @fb: framebuffer to use for new config
 * @crtc: CRTC whose configuration we're about to change
 * @mode: mode timings to use
 * @x: position of this CRTC relative to @fb
 * @y: position of this CRTC relative to @fb
 * @connectors: array of connectors to drive with this CRTC if possible
 * @num_connectors: size of @connectors array
D
Dave Airlie 已提交
1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
 *
 * Represents a single crtc the connectors that it drives with what mode
 * and from which framebuffer it scans out from.
 *
 * This is used to set modes.
 */
struct drm_mode_set {
	struct drm_framebuffer *fb;
	struct drm_crtc *crtc;
	struct drm_display_mode *mode;

	uint32_t x;
	uint32_t y;

	struct drm_connector **connectors;
	size_t num_connectors;
};

/**
1717 1718 1719
 * struct drm_mode_config_funcs - basic driver provided mode setting functions
 * @fb_create: create a new framebuffer object
 * @output_poll_changed: function to handle output configuration changes
J
John Hunter 已提交
1720
 * @atomic_check: check whether a given atomic state update is possible
D
Daniel Vetter 已提交
1721 1722
 * @atomic_commit: commit an atomic state update previously verified with
 * 	atomic_check()
1723 1724 1725
 * @atomic_state_alloc: allocate a new atomic state
 * @atomic_state_clear: clear the atomic state
 * @atomic_state_free: free the atomic state
1726 1727 1728
 *
 * Some global (i.e. not per-CRTC, connector, etc) mode setting functions that
 * involve drivers.
D
Dave Airlie 已提交
1729 1730
 */
struct drm_mode_config_funcs {
1731 1732
	struct drm_framebuffer *(*fb_create)(struct drm_device *dev,
					     struct drm_file *file_priv,
1733
					     const struct drm_mode_fb_cmd2 *mode_cmd);
1734
	void (*output_poll_changed)(struct drm_device *dev);
D
Daniel Vetter 已提交
1735 1736 1737 1738 1739 1740

	int (*atomic_check)(struct drm_device *dev,
			    struct drm_atomic_state *a);
	int (*atomic_commit)(struct drm_device *dev,
			     struct drm_atomic_state *a,
			     bool async);
1741 1742 1743
	struct drm_atomic_state *(*atomic_state_alloc)(struct drm_device *dev);
	void (*atomic_state_clear)(struct drm_atomic_state *state);
	void (*atomic_state_free)(struct drm_atomic_state *state);
D
Dave Airlie 已提交
1744 1745 1746
};

/**
D
Daniel Vetter 已提交
1747
 * struct drm_mode_config - Mode configuration control structure
1748
 * @mutex: mutex protecting KMS related lists and structures
D
Daniel Vetter 已提交
1749 1750
 * @connection_mutex: ww mutex protecting connector state and routing
 * @acquire_ctx: global implicit acquire context used by atomic drivers for
1751
 * 	legacy IOCTLs
1752 1753
 * @idr_mutex: mutex for KMS ID allocation and management
 * @crtc_idr: main KMS ID tracking object
D
Daniel Vetter 已提交
1754
 * @fb_lock: mutex to protect fb state and lists
1755 1756 1757 1758 1759 1760
 * @num_fb: number of fbs available
 * @fb_list: list of framebuffers available
 * @num_connector: number of connectors on this device
 * @connector_list: list of connector objects
 * @num_encoder: number of encoders on this device
 * @encoder_list: list of encoder objects
D
Daniel Vetter 已提交
1761 1762 1763
 * @num_overlay_plane: number of overlay planes on this device
 * @num_total_plane: number of universal (i.e. with primary/curso) planes on this device
 * @plane_list: list of plane objects
1764 1765
 * @num_crtc: number of CRTCs on this device
 * @crtc_list: list of CRTC objects
D
Daniel Vetter 已提交
1766
 * @property_list: list of property objects
1767 1768 1769 1770 1771 1772
 * @min_width: minimum pixel width on this device
 * @min_height: minimum pixel height on this device
 * @max_width: maximum pixel width on this device
 * @max_height: maximum pixel height on this device
 * @funcs: core driver provided mode setting functions
 * @fb_base: base address of the framebuffer
D
Daniel Vetter 已提交
1773 1774
 * @poll_enabled: track polling support for this device
 * @poll_running: track polling status for this device
1775
 * @output_poll_work: delayed work for polling in process context
D
Daniel Vetter 已提交
1776
 * @property_blob_list: list of all the blob property objects
D
Daniel Stone 已提交
1777
 * @blob_lock: mutex for blob property allocation and management
1778
 * @*_property: core property tracking
D
Daniel Vetter 已提交
1779 1780 1781 1782 1783
 * @preferred_depth: preferred RBG pixel depth, used by fb helpers
 * @prefer_shadow: hint to userspace to prefer shadow-fb rendering
 * @async_page_flip: does this device support async flips on the primary plane?
 * @cursor_width: hint to userspace for max cursor width
 * @cursor_height: hint to userspace for max cursor height
D
Dave Airlie 已提交
1784
 *
1785 1786 1787
 * Core mode resource tracking structure.  All CRTC, encoders, and connectors
 * enumerated by the driver are added here, as are global properties.  Some
 * global restrictions are also here, e.g. dimension restrictions.
D
Dave Airlie 已提交
1788 1789
 */
struct drm_mode_config {
J
Jesse Barnes 已提交
1790
	struct mutex mutex; /* protects configuration (mode lists etc.) */
1791 1792
	struct drm_modeset_lock connection_mutex; /* protects connector->encoder and encoder->crtc links */
	struct drm_modeset_acquire_ctx *acquire_ctx; /* for legacy _lock_all() / _unlock_all() */
J
Jesse Barnes 已提交
1793
	struct mutex idr_mutex; /* for IDR management */
D
Dave Airlie 已提交
1794
	struct idr crtc_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
D
Dave Airlie 已提交
1795
	struct idr tile_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
D
Dave Airlie 已提交
1796
	/* this is limited to one for now */
1797

D
Daniel Vetter 已提交
1798
	struct mutex fb_lock; /* proctects global and per-file fb lists */
D
Dave Airlie 已提交
1799 1800
	int num_fb;
	struct list_head fb_list;
1801

D
Dave Airlie 已提交
1802 1803 1804 1805
	int num_connector;
	struct list_head connector_list;
	int num_encoder;
	struct list_head encoder_list;
1806 1807 1808 1809 1810 1811 1812 1813 1814

	/*
	 * Track # of overlay planes separately from # of total planes.  By
	 * default we only advertise overlay planes to userspace; if userspace
	 * sets the "universal plane" capability bit, we'll go ahead and
	 * expose all planes.
	 */
	int num_overlay_plane;
	int num_total_plane;
J
Jesse Barnes 已提交
1815
	struct list_head plane_list;
D
Dave Airlie 已提交
1816 1817 1818 1819 1820 1821 1822 1823

	int num_crtc;
	struct list_head crtc_list;

	struct list_head property_list;

	int min_width, min_height;
	int max_width, max_height;
1824
	const struct drm_mode_config_funcs *funcs;
1825
	resource_size_t fb_base;
D
Dave Airlie 已提交
1826

1827 1828
	/* output poll support */
	bool poll_enabled;
1829
	bool poll_running;
1830
	bool delayed_event;
1831
	struct delayed_work output_poll_work;
1832

D
Daniel Stone 已提交
1833 1834
	struct mutex blob_lock;

D
Dave Airlie 已提交
1835 1836 1837 1838
	/* pointers to standard properties */
	struct list_head property_blob_list;
	struct drm_property *edid_property;
	struct drm_property *dpms_property;
D
Dave Airlie 已提交
1839
	struct drm_property *path_property;
1840
	struct drm_property *tile_property;
R
Rob Clark 已提交
1841
	struct drm_property *plane_type_property;
1842
	struct drm_property *rotation_property;
R
Rob Clark 已提交
1843 1844 1845 1846 1847 1848 1849 1850 1851 1852
	struct drm_property *prop_src_x;
	struct drm_property *prop_src_y;
	struct drm_property *prop_src_w;
	struct drm_property *prop_src_h;
	struct drm_property *prop_crtc_x;
	struct drm_property *prop_crtc_y;
	struct drm_property *prop_crtc_w;
	struct drm_property *prop_crtc_h;
	struct drm_property *prop_fb_id;
	struct drm_property *prop_crtc_id;
1853
	struct drm_property *prop_active;
D
Daniel Stone 已提交
1854
	struct drm_property *prop_mode_id;
D
Dave Airlie 已提交
1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867

	/* DVI-I properties */
	struct drm_property *dvi_i_subconnector_property;
	struct drm_property *dvi_i_select_subconnector_property;

	/* TV properties */
	struct drm_property *tv_subconnector_property;
	struct drm_property *tv_select_subconnector_property;
	struct drm_property *tv_mode_property;
	struct drm_property *tv_left_margin_property;
	struct drm_property *tv_right_margin_property;
	struct drm_property *tv_top_margin_property;
	struct drm_property *tv_bottom_margin_property;
1868 1869 1870
	struct drm_property *tv_brightness_property;
	struct drm_property *tv_contrast_property;
	struct drm_property *tv_flicker_reduction_property;
1871 1872 1873
	struct drm_property *tv_overscan_property;
	struct drm_property *tv_saturation_property;
	struct drm_property *tv_hue_property;
D
Dave Airlie 已提交
1874 1875 1876

	/* Optional properties */
	struct drm_property *scaling_mode_property;
1877
	struct drm_property *aspect_ratio_property;
1878
	struct drm_property *dirty_info_property;
1879

1880 1881 1882 1883
	/* properties for virtual machine layout */
	struct drm_property *suggested_x_property;
	struct drm_property *suggested_y_property;

1884 1885
	/* dumb ioctl parameters */
	uint32_t preferred_depth, prefer_shadow;
1886 1887 1888

	/* whether async page flip is supported or not */
	bool async_page_flip;
A
Alex Deucher 已提交
1889

1890 1891 1892
	/* whether the driver supports fb modifiers */
	bool allow_fb_modifiers;

A
Alex Deucher 已提交
1893 1894
	/* cursor size */
	uint32_t cursor_width, cursor_height;
D
Dave Airlie 已提交
1895 1896
};

R
Rob Clark 已提交
1897 1898 1899 1900 1901 1902 1903 1904 1905 1906
/**
 * drm_for_each_plane_mask - iterate over planes specified by bitmask
 * @plane: the loop cursor
 * @dev: the DRM device
 * @plane_mask: bitmask of plane indices
 *
 * Iterate over all planes specified by bitmask.
 */
#define drm_for_each_plane_mask(plane, dev, plane_mask) \
	list_for_each_entry((plane), &(dev)->mode_config.plane_list, head) \
1907
		for_each_if ((plane_mask) & (1 << drm_plane_index(plane)))
R
Rob Clark 已提交
1908 1909


D
Dave Airlie 已提交
1910 1911 1912 1913 1914 1915 1916
#define obj_to_crtc(x) container_of(x, struct drm_crtc, base)
#define obj_to_connector(x) container_of(x, struct drm_connector, base)
#define obj_to_encoder(x) container_of(x, struct drm_encoder, base)
#define obj_to_mode(x) container_of(x, struct drm_display_mode, base)
#define obj_to_fb(x) container_of(x, struct drm_framebuffer, base)
#define obj_to_property(x) container_of(x, struct drm_property, base)
#define obj_to_blob(x) container_of(x, struct drm_property_blob, base)
J
Jesse Barnes 已提交
1917
#define obj_to_plane(x) container_of(x, struct drm_plane, base)
D
Dave Airlie 已提交
1918

1919 1920 1921 1922
struct drm_prop_enum_list {
	int type;
	char *name;
};
D
Dave Airlie 已提交
1923

1924 1925 1926
extern int drm_crtc_init_with_planes(struct drm_device *dev,
				     struct drm_crtc *crtc,
				     struct drm_plane *primary,
1927
				     struct drm_plane *cursor,
1928
				     const struct drm_crtc_funcs *funcs);
D
Dave Airlie 已提交
1929
extern void drm_crtc_cleanup(struct drm_crtc *crtc);
1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942
extern unsigned int drm_crtc_index(struct drm_crtc *crtc);

/**
 * drm_crtc_mask - find the mask of a registered CRTC
 * @crtc: CRTC to find mask for
 *
 * Given a registered CRTC, return the mask bit of that CRTC for an
 * encoder's possible_crtcs field.
 */
static inline uint32_t drm_crtc_mask(struct drm_crtc *crtc)
{
	return 1 << drm_crtc_index(crtc);
}
D
Dave Airlie 已提交
1943

1944 1945
extern void drm_connector_ida_init(void);
extern void drm_connector_ida_destroy(void);
1946 1947 1948 1949
extern int drm_connector_init(struct drm_device *dev,
			      struct drm_connector *connector,
			      const struct drm_connector_funcs *funcs,
			      int connector_type);
1950 1951
int drm_connector_register(struct drm_connector *connector);
void drm_connector_unregister(struct drm_connector *connector);
D
Dave Airlie 已提交
1952 1953

extern void drm_connector_cleanup(struct drm_connector *connector);
1954
extern unsigned int drm_connector_index(struct drm_connector *connector);
1955 1956
/* helper to unplug all connectors from sysfs for device */
extern void drm_connector_unplug_all(struct drm_device *dev);
D
Dave Airlie 已提交
1957

1958 1959 1960 1961
extern int drm_bridge_add(struct drm_bridge *bridge);
extern void drm_bridge_remove(struct drm_bridge *bridge);
extern struct drm_bridge *of_drm_find_bridge(struct device_node *np);
extern int drm_bridge_attach(struct drm_device *dev, struct drm_bridge *bridge);
S
Sean Paul 已提交
1962

1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973
bool drm_bridge_mode_fixup(struct drm_bridge *bridge,
			const struct drm_display_mode *mode,
			struct drm_display_mode *adjusted_mode);
void drm_bridge_disable(struct drm_bridge *bridge);
void drm_bridge_post_disable(struct drm_bridge *bridge);
void drm_bridge_mode_set(struct drm_bridge *bridge,
			struct drm_display_mode *mode,
			struct drm_display_mode *adjusted_mode);
void drm_bridge_pre_enable(struct drm_bridge *bridge);
void drm_bridge_enable(struct drm_bridge *bridge);

1974 1975 1976 1977
extern int drm_encoder_init(struct drm_device *dev,
			    struct drm_encoder *encoder,
			    const struct drm_encoder_funcs *funcs,
			    int encoder_type);
D
Dave Airlie 已提交
1978

1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991
/**
 * drm_encoder_crtc_ok - can a given crtc drive a given encoder?
 * @encoder: encoder to test
 * @crtc: crtc to test
 *
 * Return false if @encoder can't be driven by @crtc, true otherwise.
 */
static inline bool drm_encoder_crtc_ok(struct drm_encoder *encoder,
				       struct drm_crtc *crtc)
{
	return !!(encoder->possible_crtcs & drm_crtc_mask(crtc));
}

M
Matt Roper 已提交
1992 1993 1994 1995 1996
extern int drm_universal_plane_init(struct drm_device *dev,
				    struct drm_plane *plane,
				    unsigned long possible_crtcs,
				    const struct drm_plane_funcs *funcs,
				    const uint32_t *formats,
1997
				    unsigned int format_count,
M
Matt Roper 已提交
1998
				    enum drm_plane_type type);
J
Jesse Barnes 已提交
1999 2000 2001 2002
extern int drm_plane_init(struct drm_device *dev,
			  struct drm_plane *plane,
			  unsigned long possible_crtcs,
			  const struct drm_plane_funcs *funcs,
2003
			  const uint32_t *formats, unsigned int format_count,
M
Matt Roper 已提交
2004
			  bool is_primary);
J
Jesse Barnes 已提交
2005
extern void drm_plane_cleanup(struct drm_plane *plane);
2006
extern unsigned int drm_plane_index(struct drm_plane *plane);
2007
extern struct drm_plane * drm_plane_from_index(struct drm_device *dev, int idx);
2008
extern void drm_plane_force_disable(struct drm_plane *plane);
2009 2010
extern int drm_plane_check_pixel_format(const struct drm_plane *plane,
					u32 format);
2011 2012
extern void drm_crtc_get_hv_timing(const struct drm_display_mode *mode,
				   int *hdisplay, int *vdisplay);
2013 2014 2015 2016
extern int drm_crtc_check_viewport(const struct drm_crtc *crtc,
				   int x, int y,
				   const struct drm_display_mode *mode,
				   const struct drm_framebuffer *fb);
J
Jesse Barnes 已提交
2017

D
Dave Airlie 已提交
2018 2019
extern void drm_encoder_cleanup(struct drm_encoder *encoder);

2020
extern const char *drm_get_connector_status_name(enum drm_connector_status status);
2021
extern const char *drm_get_subpixel_order_name(enum subpixel_order order);
2022 2023 2024 2025 2026
extern const char *drm_get_dpms_name(int val);
extern const char *drm_get_dvi_i_subconnector_name(int val);
extern const char *drm_get_dvi_i_select_name(int val);
extern const char *drm_get_tv_subconnector_name(int val);
extern const char *drm_get_tv_select_name(int val);
2027
extern void drm_fb_release(struct drm_file *file_priv);
2028 2029
extern void drm_property_destroy_user_blobs(struct drm_device *dev,
                                            struct drm_file *file_priv);
A
Adam Jackson 已提交
2030
extern bool drm_probe_ddc(struct i2c_adapter *adapter);
D
Dave Airlie 已提交
2031 2032
extern struct edid *drm_get_edid(struct drm_connector *connector,
				 struct i2c_adapter *adapter);
J
Jani Nikula 已提交
2033
extern struct edid *drm_edid_duplicate(const struct edid *edid);
D
Dave Airlie 已提交
2034 2035
extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid);
extern void drm_mode_config_init(struct drm_device *dev);
2036
extern void drm_mode_config_reset(struct drm_device *dev);
D
Dave Airlie 已提交
2037
extern void drm_mode_config_cleanup(struct drm_device *dev);
2038

D
Dave Airlie 已提交
2039
extern int drm_mode_connector_set_path_property(struct drm_connector *connector,
2040
						const char *path);
2041
int drm_mode_connector_set_tile_property(struct drm_connector *connector);
D
Dave Airlie 已提交
2042
extern int drm_mode_connector_update_edid_property(struct drm_connector *connector,
2043
						   const struct edid *edid);
R
Rob Clark 已提交
2044

2045 2046 2047 2048
extern int drm_display_info_set_bus_formats(struct drm_display_info *info,
					    const u32 *formats,
					    unsigned int num_formats);

R
Rob Clark 已提交
2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064
static inline bool drm_property_type_is(struct drm_property *property,
		uint32_t type)
{
	/* instanceof for props.. handles extended type vs original types: */
	if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE)
		return (property->flags & DRM_MODE_PROP_EXTENDED_TYPE) == type;
	return property->flags & type;
}

static inline bool drm_property_type_valid(struct drm_property *property)
{
	if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE)
		return !(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
	return !!(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
}

2065 2066 2067 2068 2069 2070
extern int drm_object_property_set_value(struct drm_mode_object *obj,
					 struct drm_property *property,
					 uint64_t val);
extern int drm_object_property_get_value(struct drm_mode_object *obj,
					 struct drm_property *property,
					 uint64_t *value);
D
Dave Airlie 已提交
2071 2072 2073
extern int drm_framebuffer_init(struct drm_device *dev,
				struct drm_framebuffer *fb,
				const struct drm_framebuffer_funcs *funcs);
2074 2075
extern struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
						      uint32_t id);
R
Rob Clark 已提交
2076 2077 2078
extern void drm_framebuffer_unreference(struct drm_framebuffer *fb);
extern void drm_framebuffer_reference(struct drm_framebuffer *fb);
extern void drm_framebuffer_remove(struct drm_framebuffer *fb);
D
Dave Airlie 已提交
2079
extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb);
2080
extern void drm_framebuffer_unregister_private(struct drm_framebuffer *fb);
D
Dave Airlie 已提交
2081

2082 2083 2084
extern void drm_object_attach_property(struct drm_mode_object *obj,
				       struct drm_property *property,
				       uint64_t init_val);
D
Dave Airlie 已提交
2085 2086
extern struct drm_property *drm_property_create(struct drm_device *dev, int flags,
						const char *name, int num_values);
2087 2088
extern struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags,
					 const char *name,
R
Rob Clark 已提交
2089 2090 2091 2092
					 const struct drm_prop_enum_list *props,
					 int num_values);
struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
					 int flags, const char *name,
2093
					 const struct drm_prop_enum_list *props,
2094 2095
					 int num_props,
					 uint64_t supported_bits);
2096 2097 2098
struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
					 const char *name,
					 uint64_t min, uint64_t max);
R
Rob Clark 已提交
2099 2100 2101
struct drm_property *drm_property_create_signed_range(struct drm_device *dev,
					 int flags, const char *name,
					 int64_t min, int64_t max);
R
Rob Clark 已提交
2102 2103
struct drm_property *drm_property_create_object(struct drm_device *dev,
					 int flags, const char *name, uint32_t type);
2104 2105
struct drm_property *drm_property_create_bool(struct drm_device *dev, int flags,
					 const char *name);
2106 2107 2108 2109 2110 2111 2112
struct drm_property_blob *drm_property_create_blob(struct drm_device *dev,
                                                   size_t length,
                                                   const void *data);
struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev,
                                                   uint32_t id);
struct drm_property_blob *drm_property_reference_blob(struct drm_property_blob *blob);
void drm_property_unreference_blob(struct drm_property_blob *blob);
D
Dave Airlie 已提交
2113 2114 2115 2116
extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property);
extern int drm_property_add_enum(struct drm_property *property, int index,
				 uint64_t value, const char *name);
extern int drm_mode_create_dvi_i_properties(struct drm_device *dev);
2117 2118
extern int drm_mode_create_tv_properties(struct drm_device *dev,
					 unsigned int num_modes,
V
Ville Syrjälä 已提交
2119
					 const char * const modes[]);
D
Dave Airlie 已提交
2120
extern int drm_mode_create_scaling_mode_property(struct drm_device *dev);
2121
extern int drm_mode_create_aspect_ratio_property(struct drm_device *dev);
2122
extern int drm_mode_create_dirty_info_property(struct drm_device *dev);
2123
extern int drm_mode_create_suggested_offset_properties(struct drm_device *dev);
R
Rob Clark 已提交
2124 2125 2126 2127
extern bool drm_property_change_valid_get(struct drm_property *property,
					 uint64_t value, struct drm_mode_object **ref);
extern void drm_property_change_valid_put(struct drm_property *property,
		struct drm_mode_object *ref);
D
Dave Airlie 已提交
2128 2129 2130

extern int drm_mode_connector_attach_encoder(struct drm_connector *connector,
					     struct drm_encoder *encoder);
2131
extern int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
D
Dave Airlie 已提交
2132
					 int gamma_size);
2133 2134
extern struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
		uint32_t id, uint32_t type);
R
Rob Clark 已提交
2135

D
Dave Airlie 已提交
2136 2137 2138
/* IOCTLs */
extern int drm_mode_getresources(struct drm_device *dev,
				 void *data, struct drm_file *file_priv);
J
Jesse Barnes 已提交
2139 2140
extern int drm_mode_getplane_res(struct drm_device *dev, void *data,
				   struct drm_file *file_priv);
D
Dave Airlie 已提交
2141 2142 2143 2144
extern int drm_mode_getcrtc(struct drm_device *dev,
			    void *data, struct drm_file *file_priv);
extern int drm_mode_getconnector(struct drm_device *dev,
			      void *data, struct drm_file *file_priv);
2145
extern int drm_mode_set_config_internal(struct drm_mode_set *set);
D
Dave Airlie 已提交
2146 2147
extern int drm_mode_setcrtc(struct drm_device *dev,
			    void *data, struct drm_file *file_priv);
J
Jesse Barnes 已提交
2148 2149 2150 2151
extern int drm_mode_getplane(struct drm_device *dev,
			       void *data, struct drm_file *file_priv);
extern int drm_mode_setplane(struct drm_device *dev,
			       void *data, struct drm_file *file_priv);
D
Dave Airlie 已提交
2152 2153
extern int drm_mode_cursor_ioctl(struct drm_device *dev,
				void *data, struct drm_file *file_priv);
2154 2155
extern int drm_mode_cursor2_ioctl(struct drm_device *dev,
				void *data, struct drm_file *file_priv);
D
Dave Airlie 已提交
2156 2157
extern int drm_mode_addfb(struct drm_device *dev,
			  void *data, struct drm_file *file_priv);
2158 2159 2160
extern int drm_mode_addfb2(struct drm_device *dev,
			   void *data, struct drm_file *file_priv);
extern uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth);
D
Dave Airlie 已提交
2161 2162 2163 2164
extern int drm_mode_rmfb(struct drm_device *dev,
			 void *data, struct drm_file *file_priv);
extern int drm_mode_getfb(struct drm_device *dev,
			  void *data, struct drm_file *file_priv);
2165 2166
extern int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
				  void *data, struct drm_file *file_priv);
D
Dave Airlie 已提交
2167 2168 2169 2170 2171

extern int drm_mode_getproperty_ioctl(struct drm_device *dev,
				      void *data, struct drm_file *file_priv);
extern int drm_mode_getblob_ioctl(struct drm_device *dev,
				  void *data, struct drm_file *file_priv);
2172 2173 2174 2175
extern int drm_mode_createblob_ioctl(struct drm_device *dev,
				     void *data, struct drm_file *file_priv);
extern int drm_mode_destroyblob_ioctl(struct drm_device *dev,
				      void *data, struct drm_file *file_priv);
D
Dave Airlie 已提交
2176 2177 2178 2179 2180 2181 2182 2183
extern int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
					      void *data, struct drm_file *file_priv);
extern int drm_mode_getencoder(struct drm_device *dev,
			       void *data, struct drm_file *file_priv);
extern int drm_mode_gamma_get_ioctl(struct drm_device *dev,
				    void *data, struct drm_file *file_priv);
extern int drm_mode_gamma_set_ioctl(struct drm_device *dev,
				    void *data, struct drm_file *file_priv);
2184
extern u8 drm_match_cea_mode(const struct drm_display_mode *to_match);
2185
extern enum hdmi_picture_aspect drm_get_cea_aspect_ratio(const u8 video_code);
2186
extern bool drm_detect_hdmi_monitor(struct edid *edid);
2187
extern bool drm_detect_monitor_audio(struct edid *edid);
2188
extern bool drm_rgb_quant_range_selectable(struct edid *edid);
2189 2190
extern int drm_mode_page_flip_ioctl(struct drm_device *dev,
				    void *data, struct drm_file *file_priv);
2191 2192
extern int drm_add_modes_noedid(struct drm_connector *connector,
				int hdisplay, int vdisplay);
G
Gerd Hoffmann 已提交
2193 2194
extern void drm_set_preferred_mode(struct drm_connector *connector,
				   int hpref, int vpref);
2195

2196
extern int drm_edid_header_is_valid(const u8 *raw_edid);
2197 2198
extern bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid,
				 bool *edid_corrupt);
2199
extern bool drm_edid_is_valid(struct edid *edid);
D
Dave Airlie 已提交
2200 2201 2202 2203 2204 2205 2206

extern struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev,
							 char topology[8]);
extern struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev,
					       char topology[8]);
extern void drm_mode_put_tile_group(struct drm_device *dev,
				   struct drm_tile_group *tg);
D
Dave Airlie 已提交
2207
struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
2208 2209
					   int hsize, int vsize, int fresh,
					   bool rb);
2210 2211 2212 2213 2214 2215 2216

extern int drm_mode_create_dumb_ioctl(struct drm_device *dev,
				      void *data, struct drm_file *file_priv);
extern int drm_mode_mmap_dumb_ioctl(struct drm_device *dev,
				    void *data, struct drm_file *file_priv);
extern int drm_mode_destroy_dumb_ioctl(struct drm_device *dev,
				      void *data, struct drm_file *file_priv);
2217 2218 2219 2220
extern int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
					     struct drm_file *file_priv);
extern int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
					   struct drm_file *file_priv);
2221 2222 2223
extern int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
				       struct drm_property *property,
				       uint64_t value);
R
Rob Clark 已提交
2224 2225
extern int drm_mode_atomic_ioctl(struct drm_device *dev,
				 void *data, struct drm_file *file_priv);
2226 2227 2228

extern void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
				 int *bpp);
2229
extern int drm_format_num_planes(uint32_t format);
2230
extern int drm_format_plane_cpp(uint32_t format, int plane);
2231 2232
extern int drm_format_horz_chroma_subsampling(uint32_t format);
extern int drm_format_vert_chroma_subsampling(uint32_t format);
2233
extern const char *drm_get_format_name(uint32_t format);
2234 2235
extern struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev,
							      unsigned int supported_rotations);
2236 2237
extern unsigned int drm_rotation_simplify(unsigned int rotation,
					  unsigned int supported_rotations);
2238

R
Russell King 已提交
2239
/* Helpers */
R
Rob Clark 已提交
2240 2241 2242 2243 2244 2245 2246 2247 2248

static inline struct drm_plane *drm_plane_find(struct drm_device *dev,
		uint32_t id)
{
	struct drm_mode_object *mo;
	mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PLANE);
	return mo ? obj_to_plane(mo) : NULL;
}

R
Russell King 已提交
2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264
static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev,
	uint32_t id)
{
	struct drm_mode_object *mo;
	mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CRTC);
	return mo ? obj_to_crtc(mo) : NULL;
}

static inline struct drm_encoder *drm_encoder_find(struct drm_device *dev,
	uint32_t id)
{
	struct drm_mode_object *mo;
	mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
	return mo ? obj_to_encoder(mo) : NULL;
}

R
Rob Clark 已提交
2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280
static inline struct drm_connector *drm_connector_find(struct drm_device *dev,
		uint32_t id)
{
	struct drm_mode_object *mo;
	mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CONNECTOR);
	return mo ? obj_to_connector(mo) : NULL;
}

static inline struct drm_property *drm_property_find(struct drm_device *dev,
		uint32_t id)
{
	struct drm_mode_object *mo;
	mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PROPERTY);
	return mo ? obj_to_property(mo) : NULL;
}

2281
/* Plane list iterator for legacy (overlay only) planes. */
2282 2283
#define drm_for_each_legacy_plane(plane, dev) \
	list_for_each_entry(plane, &(dev)->mode_config.plane_list, head) \
2284
		for_each_if (plane->type == DRM_PLANE_TYPE_OVERLAY)
2285

2286 2287 2288 2289 2290 2291
#define drm_for_each_plane(plane, dev) \
	list_for_each_entry(plane, &(dev)->mode_config.plane_list, head)

#define drm_for_each_crtc(crtc, dev) \
	list_for_each_entry(crtc, &(dev)->mode_config.crtc_list, head)

2292 2293 2294
static inline void
assert_drm_connector_list_read_locked(struct drm_mode_config *mode_config)
{
2295 2296 2297 2298 2299 2300 2301 2302 2303
	/*
	 * The connector hotadd/remove code currently grabs both locks when
	 * updating lists. Hence readers need only hold either of them to be
	 * safe and the check amounts to
	 *
	 * WARN_ON(not_holding(A) && not_holding(B)).
	 */
	WARN_ON(!mutex_is_locked(&mode_config->mutex) &&
		!drm_modeset_is_locked(&mode_config->connection_mutex));
2304 2305
}

2306
#define drm_for_each_connector(connector, dev) \
2307 2308 2309 2310 2311
	for (assert_drm_connector_list_read_locked(&(dev)->mode_config),	\
	     connector = list_first_entry(&(dev)->mode_config.connector_list,	\
					  struct drm_connector, head);		\
	     &connector->head != (&(dev)->mode_config.connector_list);		\
	     connector = list_next_entry(connector, head))
2312 2313 2314 2315 2316

#define drm_for_each_encoder(encoder, dev) \
	list_for_each_entry(encoder, &(dev)->mode_config.encoder_list, head)

#define drm_for_each_fb(fb, dev) \
2317 2318 2319 2320 2321
	for (WARN_ON(!mutex_is_locked(&(dev)->mode_config.fb_lock)),		\
	     fb = list_first_entry(&(dev)->mode_config.fb_list,	\
					  struct drm_framebuffer, head);	\
	     &fb->head != (&(dev)->mode_config.fb_list);			\
	     fb = list_next_entry(fb, head))
2322

D
Dave Airlie 已提交
2323
#endif /* __DRM_CRTC_H__ */