drm_crtc.h 99.3 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

struct drm_mode_object {
	uint32_t id;
	uint32_t type;
51
	struct drm_object_properties *properties;
52 53
	struct kref refcount;
	void (*free_cb)(struct kref *kref);
54 55
};

56
#define DRM_OBJECT_MAX_PROPERTY 24
57
struct drm_object_properties {
R
Rob Clark 已提交
58
	int count, atomic_count;
59 60 61 62 63 64
	/* 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];
65 66 67
	/* do not read/write values directly, but use drm_object_property_get_value()
	 * and drm_object_property_set_value():
	 */
68
	uint64_t values[DRM_OBJECT_MAX_PROPERTY];
D
Dave Airlie 已提交
69 70
};

R
Rob Clark 已提交
71 72 73 74 75 76 77 78 79
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);
}

80 81 82 83 84
/*
 * 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
 */
85
#define DRM_ROTATE_MASK 0x0f
86 87 88 89
#define DRM_ROTATE_0	0
#define DRM_ROTATE_90	1
#define DRM_ROTATE_180	2
#define DRM_ROTATE_270	3
90
#define DRM_REFLECT_MASK (~DRM_ROTATE_MASK)
91 92 93
#define DRM_REFLECT_X	4
#define DRM_REFLECT_Y	5

94 95 96 97 98
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 已提交
99 100
};

101
#include <drm/drm_modes.h>
102

D
Dave Airlie 已提交
103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
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,
};

118 119 120
#define DRM_COLOR_FORMAT_RGB444		(1<<0)
#define DRM_COLOR_FORMAT_YCRCB444	(1<<1)
#define DRM_COLOR_FORMAT_YCRCB422	(1<<2)
121 122 123 124 125 126 127 128

#define DRM_BUS_FLAG_DE_LOW		(1<<0)
#define DRM_BUS_FLAG_DE_HIGH		(1<<1)
/* drive data on pos. edge */
#define DRM_BUS_FLAG_PIXDATA_POSEDGE	(1<<2)
/* drive data on neg. edge */
#define DRM_BUS_FLAG_PIXDATA_NEGEDGE	(1<<3)

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
	const u32 *bus_formats;
	unsigned int num_bus_formats;
150
	u32 bus_flags;
151

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

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

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

166 167 168
/**
 * struct drm_framebuffer_funcs - framebuffer hooks
 */
D
Dave Airlie 已提交
169
struct drm_framebuffer_funcs {
170 171 172 173 174 175
	/**
	 * @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
176 177 178
	 * &drm_mode_config_funcs. Drivers must also call
	 * drm_framebuffer_cleanup() to release DRM core resources for this
	 * framebuffer.
179
	 */
D
Dave Airlie 已提交
180
	void (*destroy)(struct drm_framebuffer *framebuffer);
181 182 183 184 185 186 187 188 189 190 191 192

	/**
	 * @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.
	 *
193 194 195
	 * GEM based drivers should call drm_gem_handle_create() to create the
	 * handle.
	 *
196 197 198 199
	 * RETURNS:
	 *
	 * 0 on success or a negative error code on failure.
	 */
D
Dave Airlie 已提交
200 201 202
	int (*create_handle)(struct drm_framebuffer *fb,
			     struct drm_file *file_priv,
			     unsigned int *handle);
203 204
	/**
	 * @dirty:
205
	 *
206
	 * Optional callback for the dirty fb IOCTL.
207
	 *
208 209 210 211 212 213 214 215 216 217 218 219
	 * 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.
220
	 */
221 222
	int (*dirty)(struct drm_framebuffer *framebuffer,
		     struct drm_file *file_priv, unsigned flags,
223 224
		     unsigned color, struct drm_clip_rect *clips,
		     unsigned num_clips);
D
Dave Airlie 已提交
225 226 227 228
};

struct drm_framebuffer {
	struct drm_device *dev;
R
Rob Clark 已提交
229 230 231 232 233 234 235 236
	/*
	 * 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.
237
	 * The refcount is stored inside the mode object.
R
Rob Clark 已提交
238
	 */
239 240 241 242
	/*
	 * Place on the dev->mode_config.fb_list, access protected by
	 * dev->mode_config.fb_lock.
	 */
D
Dave Airlie 已提交
243 244 245
	struct list_head head;
	struct drm_mode_object base;
	const struct drm_framebuffer_funcs *funcs;
246 247
	unsigned int pitches[4];
	unsigned int offsets[4];
248
	uint64_t modifier[4];
D
Dave Airlie 已提交
249 250 251 252 253 254
	unsigned int width;
	unsigned int height;
	/* depth can be 15 or 16 */
	unsigned int depth;
	int bits_per_pixel;
	int flags;
255
	uint32_t pixel_format; /* fourcc format */
D
Dave Airlie 已提交
256 257 258 259 260
	struct list_head filp_head;
};

struct drm_property_blob {
	struct drm_mode_object base;
261
	struct drm_device *dev;
262 263
	struct list_head head_global;
	struct list_head head_file;
264
	size_t length;
265
	unsigned char data[];
D
Dave Airlie 已提交
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
};

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 已提交
281
	struct drm_device *dev;
D
Dave Airlie 已提交
282

283
	struct list_head enum_list;
D
Dave Airlie 已提交
284 285 286 287 288
};

struct drm_crtc;
struct drm_connector;
struct drm_encoder;
289
struct drm_pending_vblank_event;
J
Jesse Barnes 已提交
290
struct drm_plane;
S
Sean Paul 已提交
291
struct drm_bridge;
292 293
struct drm_atomic_state;

294 295 296 297 298
struct drm_crtc_helper_funcs;
struct drm_encoder_helper_funcs;
struct drm_connector_helper_funcs;
struct drm_plane_helper_funcs;

299
/**
D
Daniel Vetter 已提交
300
 * struct drm_crtc_state - mutable CRTC state
301
 * @crtc: backpointer to the CRTC
302
 * @enable: whether the CRTC should be enabled, gates all other state
303
 * @active: whether the CRTC is actively displaying (used for DPMS)
304 305 306 307
 * @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
308 309
 * @color_mgmt_changed: color management properties have changed (degamma or
 *	gamma LUT or CSC matrix)
310
 * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes
311
 * @connector_mask: bitmask of (1 << drm_connector_index(connector)) of attached connectors
312
 * @encoder_mask: bitmask of (1 << drm_encoder_index(encoder)) of attached encoders
313 314
 * @last_vblank_count: for helpers and drivers to capture the vblank of the
 * 	update to ensure framebuffer cleanup isn't done too early
315
 * @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings
316
 * @mode: current mode timings
317
 * @mode_blob: &drm_property_blob for @mode
318 319 320 321 322
 * @degamma_lut: Lookup table for converting framebuffer pixel data
 *	before apply the conversion matrix
 * @ctm: Transformation matrix
 * @gamma_lut: Lookup table for converting pixel data after the
 *	conversion matrix
323 324 325
 * @event: optional pointer to a DRM event to signal upon completion of the
 * 	state update
 * @state: backpointer to global drm_atomic_state
326 327 328 329 330 331
 *
 * 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.
332 333
 */
struct drm_crtc_state {
334 335
	struct drm_crtc *crtc;

D
Daniel Vetter 已提交
336
	bool enable;
337
	bool active;
338

D
Daniel Vetter 已提交
339 340
	/* computed state bits used by helpers and drivers */
	bool planes_changed : 1;
341
	bool mode_changed : 1;
342
	bool active_changed : 1;
343
	bool connectors_changed : 1;
344
	bool color_mgmt_changed : 1;
345

346 347 348 349 350 351 352
	/* 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;

353
	u32 connector_mask;
354
	u32 encoder_mask;
355

356 357
	/* last_vblank_count: for vblank waits before cleanup */
	u32 last_vblank_count;
D
Daniel Vetter 已提交
358

359 360 361
	/* adjusted_mode: for use by helpers and drivers */
	struct drm_display_mode adjusted_mode;

362 363
	struct drm_display_mode mode;

364 365 366
	/* blob property to expose current mode to atomic userspace */
	struct drm_property_blob *mode_blob;

367 368 369 370 371
	/* blob property to expose color management to userspace */
	struct drm_property_blob *degamma_lut;
	struct drm_property_blob *ctm;
	struct drm_property_blob *gamma_lut;

372 373 374 375
	struct drm_pending_vblank_event *event;

	struct drm_atomic_state *state;
};
D
Dave Airlie 已提交
376 377

/**
378
 * struct drm_crtc_funcs - control CRTCs for a given device
D
Dave Airlie 已提交
379 380 381 382 383 384 385 386 387 388 389
 *
 * 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 {
390 391 392 393 394 395 396 397 398 399
	/**
	 * @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.
	 */
400
	void (*reset)(struct drm_crtc *crtc);
D
Dave Airlie 已提交
401

D
Daniel Vetter 已提交
402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
	/**
	 * @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 已提交
423 424
	int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv,
			  uint32_t handle, uint32_t width, uint32_t height);
D
Daniel Vetter 已提交
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444

	/**
	 * @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.
	 */
445 446 447
	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 已提交
448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464

	/**
	 * @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 已提交
465 466
	int (*cursor_move)(struct drm_crtc *crtc, int x, int y);

D
Daniel Vetter 已提交
467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
	/**
	 * @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 已提交
482
	void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
J
James Simmons 已提交
483
			  uint32_t start, uint32_t size);
484 485 486 487 488 489 490 491

	/**
	 * @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 已提交
492 493
	void (*destroy)(struct drm_crtc *crtc);

D
Daniel Vetter 已提交
494 495 496 497 498 499 500 501 502 503 504 505 506 507
	/**
	 * @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 已提交
508
	int (*set_config)(struct drm_mode_set *set);
509

D
Daniel Vetter 已提交
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 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569
	/**
	 * @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
570 571
	 * "ACTIVE" state) should result in an -EINVAL error code. Note that
	 * drm_atomic_helper_page_flip() checks this already for atomic drivers.
572 573 574
	 */
	int (*page_flip)(struct drm_crtc *crtc,
			 struct drm_framebuffer *fb,
575 576
			 struct drm_pending_vblank_event *event,
			 uint32_t flags);
P
Paulo Zanoni 已提交
577

578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
	/**
	 * @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 已提交
594 595
	int (*set_property)(struct drm_crtc *crtc,
			    struct drm_property *property, uint64_t val);
596

597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
	/**
	 * @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.
	 */
626
	struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc);
627 628 629 630 631 632 633

	/**
	 * @atomic_destroy_state:
	 *
	 * Destroy a state duplicated with @atomic_duplicate_state and release
	 * or unreference all resources it references
	 */
634
	void (*atomic_destroy_state)(struct drm_crtc *crtc,
D
Daniel Vetter 已提交
635
				     struct drm_crtc_state *state);
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678

	/**
	 * @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.
	 */
679 680 681 682
	int (*atomic_set_property)(struct drm_crtc *crtc,
				   struct drm_crtc_state *state,
				   struct drm_property *property,
				   uint64_t val);
683 684 685 686
	/**
	 * @atomic_get_property:
	 *
	 * Reads out the decoded driver-private property. This is used to
687
	 * implement the GETCRTC IOCTL.
688 689 690 691 692 693 694 695 696 697 698 699 700
	 *
	 * 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 已提交
701 702 703 704
	int (*atomic_get_property)(struct drm_crtc *crtc,
				   const struct drm_crtc_state *state,
				   struct drm_property *property,
				   uint64_t *val);
D
Dave Airlie 已提交
705 706 707
};

/**
708
 * struct drm_crtc - central CRTC control structure
709
 * @dev: parent DRM device
D
Daniel Vetter 已提交
710
 * @port: OF node used by drm_of_find_possible_crtcs()
711
 * @head: list management
712
 * @name: human readable name, can be overwritten by the driver
713
 * @mutex: per-CRTC locking
714
 * @base: base KMS object for ID tracking etc.
715 716
 * @primary: primary plane for this CRTC
 * @cursor: cursor plane for this CRTC
D
Daniel Vetter 已提交
717 718
 * @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 已提交
719
 * @enabled: is this CRTC enabled?
720 721
 * @mode: current mode timings
 * @hwmode: mode timings as programmed to hw regs
D
Dave Airlie 已提交
722 723 724
 * @x: x position on screen
 * @y: y position on screen
 * @funcs: CRTC control functions
725 726 727
 * @gamma_size: size of gamma ramp
 * @gamma_store: gamma ramp values
 * @helper_private: mid-layer private data
P
Paulo Zanoni 已提交
728
 * @properties: property tracking for this CRTC
729
 * @state: current atomic state for this CRTC
D
Daniel Vetter 已提交
730
 * @acquire_ctx: per-CRTC implicit acquire context used by atomic drivers for
731
 * 	legacy IOCTLs
D
Dave Airlie 已提交
732 733 734 735 736 737
 *
 * 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;
738
	struct device_node *port;
D
Dave Airlie 已提交
739 740
	struct list_head head;

741 742
	char *name;

743 744
	/**
	 * @mutex:
D
Daniel Vetter 已提交
745 746 747
	 *
	 * This provides a read lock for the overall crtc state (mode, dpms
	 * state, ...) and a write lock for everything which can be update
748 749
	 * without a full modeset (fb, cursor data, crtc properties ...). Full
	 * modeset also need to grab dev->mode_config.connection_mutex.
D
Daniel Vetter 已提交
750
	 */
751
	struct drm_modeset_lock mutex;
D
Daniel Vetter 已提交
752

D
Dave Airlie 已提交
753 754
	struct drm_mode_object base;

755 756 757 758
	/* primary and cursor planes for CRTC */
	struct drm_plane *primary;
	struct drm_plane *cursor;

C
Chris Wilson 已提交
759 760 761
	/* position inside the mode_config.list, can be used as a [] idx */
	unsigned index;

762 763 764 765
	/* position of cursor plane on crtc */
	int cursor_x;
	int cursor_y;

D
Dave Airlie 已提交
766 767
	bool enabled;

768
	/* Requested mode from modesetting. */
D
Dave Airlie 已提交
769 770
	struct drm_display_mode mode;

771 772 773 774 775
	/* Programmed mode in hw, after adjustments for encoders,
	 * crtc, panel scaling etc. Needed for timestamping etc.
	 */
	struct drm_display_mode hwmode;

D
Dave Airlie 已提交
776 777 778
	int x, y;
	const struct drm_crtc_funcs *funcs;

779
	/* Legacy FB CRTC gamma size for reporting to userspace */
D
Dave Airlie 已提交
780 781 782 783
	uint32_t gamma_size;
	uint16_t *gamma_store;

	/* if you are using the helper */
784
	const struct drm_crtc_helper_funcs *helper_private;
P
Paulo Zanoni 已提交
785 786

	struct drm_object_properties properties;
787

788 789
	struct drm_crtc_state *state;

790
	/*
791
	 * For legacy crtc IOCTLs so that atomic drivers can get at the locking
792 793 794
	 * acquire context.
	 */
	struct drm_modeset_acquire_ctx *acquire_ctx;
D
Dave Airlie 已提交
795 796
};

797 798
/**
 * struct drm_connector_state - mutable connector state
799
 * @connector: backpointer to the connector
D
Daniel Vetter 已提交
800
 * @crtc: CRTC to connect connector to, NULL if disabled
801
 * @best_encoder: can be used by helpers and drivers to select the encoder
802 803 804
 * @state: backpointer to global drm_atomic_state
 */
struct drm_connector_state {
805 806
	struct drm_connector *connector;

807
	struct drm_crtc *crtc;  /* do not write directly, use drm_atomic_set_crtc_for_connector() */
808

809 810
	struct drm_encoder *best_encoder;

811 812
	struct drm_atomic_state *state;
};
D
Dave Airlie 已提交
813 814

/**
815
 * struct drm_connector_funcs - control connectors on a given device
816
 *
D
Dave Airlie 已提交
817 818 819 820 821
 * 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 已提交
822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837
	/**
	 * @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.
	 */
838
	int (*dpms)(struct drm_connector *connector, int mode);
839 840 841 842 843 844 845 846 847 848 849

	/**
	 * @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.
	 */
850
	void (*reset)(struct drm_connector *connector);
851

D
Daniel Vetter 已提交
852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
	/**
	 * @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.
869
	 */
870
	enum drm_connector_status (*detect)(struct drm_connector *connector,
871
					    bool force);
D
Daniel Vetter 已提交
872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912

	/**
	 * @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 已提交
913
	int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height);
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930

	/**
	 * @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 已提交
931 932
	int (*set_property)(struct drm_connector *connector, struct drm_property *property,
			     uint64_t val);
933 934 935 936 937 938 939 940 941

	/**
	 * @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 已提交
942
	void (*destroy)(struct drm_connector *connector);
943

944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972
	/**
	 * @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.
	 */
973
	struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector);
974 975 976 977 978 979 980

	/**
	 * @atomic_destroy_state:
	 *
	 * Destroy a state duplicated with @atomic_duplicate_state and release
	 * or unreference all resources it references
	 */
981
	void (*atomic_destroy_state)(struct drm_connector *connector,
D
Daniel Vetter 已提交
982
				     struct drm_connector_state *state);
983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025

	/**
	 * @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.
	 */
1026 1027 1028 1029
	int (*atomic_set_property)(struct drm_connector *connector,
				   struct drm_connector_state *state,
				   struct drm_property *property,
				   uint64_t val);
1030 1031 1032 1033 1034

	/**
	 * @atomic_get_property:
	 *
	 * Reads out the decoded driver-private property. This is used to
1035
	 * implement the GETCONNECTOR IOCTL.
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
	 *
	 * 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 已提交
1049 1050 1051 1052
	int (*atomic_get_property)(struct drm_connector *connector,
				   const struct drm_connector_state *state,
				   struct drm_property *property,
				   uint64_t *val);
D
Dave Airlie 已提交
1053 1054
};

1055
/**
1056
 * struct drm_encoder_funcs - encoder controls
1057 1058 1059
 *
 * Encoders sit between CRTCs and connectors.
 */
D
Dave Airlie 已提交
1060
struct drm_encoder_funcs {
1061 1062 1063 1064 1065 1066 1067
	/**
	 * @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.
	 */
1068
	void (*reset)(struct drm_encoder *encoder);
1069 1070 1071 1072 1073 1074 1075 1076

	/**
	 * @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 已提交
1077 1078 1079
	void (*destroy)(struct drm_encoder *encoder);
};

1080
#define DRM_CONNECTOR_MAX_ENCODER 3
D
Dave Airlie 已提交
1081 1082

/**
1083
 * struct drm_encoder - central DRM encoder structure
J
Jesse Barnes 已提交
1084 1085 1086
 * @dev: parent DRM device
 * @head: list management
 * @base: base KMS object
1087
 * @name: human readable name, can be overwritten by the driver
J
Jesse Barnes 已提交
1088 1089 1090 1091
 * @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 已提交
1092
 * @bridge: bridge associated to the encoder
J
Jesse Barnes 已提交
1093 1094 1095 1096 1097
 * @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 已提交
1098 1099 1100 1101 1102 1103
 */
struct drm_encoder {
	struct drm_device *dev;
	struct list_head head;

	struct drm_mode_object base;
1104
	char *name;
D
Dave Airlie 已提交
1105
	int encoder_type;
C
Chris Wilson 已提交
1106 1107 1108 1109

	/* position inside the mode_config.list, can be used as a [] idx */
	unsigned index;

D
Dave Airlie 已提交
1110 1111 1112 1113
	uint32_t possible_crtcs;
	uint32_t possible_clones;

	struct drm_crtc *crtc;
S
Sean Paul 已提交
1114
	struct drm_bridge *bridge;
D
Dave Airlie 已提交
1115
	const struct drm_encoder_funcs *funcs;
1116
	const struct drm_encoder_helper_funcs *helper_private;
D
Dave Airlie 已提交
1117 1118
};

1119 1120 1121 1122 1123 1124 1125 1126 1127
/* 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)

1128 1129
#define MAX_ELD_BYTES	128

D
Dave Airlie 已提交
1130
/**
1131
 * struct drm_connector - central DRM connector control structure
1132 1133 1134 1135 1136
 * @dev: parent DRM device
 * @kdev: kernel device for sysfs attributes
 * @attr: sysfs attributes
 * @head: list management
 * @base: base KMS object
1137 1138
 * @name: human readable name, can be overwritten by the driver
 * @connector_id: compacted connector id useful indexing arrays
1139 1140
 * @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 已提交
1141 1142
 * @interlace_allowed: can this connector handle interlaced modes?
 * @doublescan_allowed: can this connector handle doublescan?
D
Daniel Vetter 已提交
1143
 * @stereo_allowed: can this connector handle stereo modes?
1144 1145 1146 1147
 * @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 已提交
1148
 * @funcs: connector control functions
1149
 * @edid_blob_ptr: DRM property containing EDID if present
1150
 * @properties: property tracking for this connector
1151 1152 1153
 * @polled: a %DRM_CONNECTOR_POLL_<foo> value for core driven polling
 * @dpms: current dpms state
 * @helper_private: mid-layer private data
D
Daniel Vetter 已提交
1154
 * @cmdline_mode: mode line parsed from the kernel cmdline for this connector
1155
 * @force: a %DRM_FORCE_<foo> state for forced mode sets
D
Daniel Vetter 已提交
1156
 * @override_edid: has the EDID been overwritten through debugfs for testing?
1157 1158 1159 1160 1161 1162 1163 1164 1165
 * @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 已提交
1166
 * @bad_edid_counter: track sinks that give us an EDID with invalid checksum
1167
 * @edid_corrupt: indicates whether the last read EDID was corrupt
D
Daniel Vetter 已提交
1168
 * @debugfs_entry: debugfs directory for this connector
1169
 * @state: current atomic state for this connector
1170 1171 1172 1173 1174 1175 1176 1177 1178
 * @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 已提交
1179 1180 1181 1182 1183 1184 1185 1186
 *
 * 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;
1187
	struct device *kdev;
D
Dave Airlie 已提交
1188 1189 1190 1191 1192
	struct device_attribute *attr;
	struct list_head head;

	struct drm_mode_object base;

1193
	char *name;
1194
	int connector_id;
D
Dave Airlie 已提交
1195 1196 1197 1198
	int connector_type;
	int connector_type_id;
	bool interlace_allowed;
	bool doublescan_allowed;
1199
	bool stereo_allowed;
D
Dave Airlie 已提交
1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210
	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;
1211
	struct drm_object_properties properties;
D
Dave Airlie 已提交
1212

1213 1214 1215 1216 1217
	/**
	 * @path_blob_ptr:
	 *
	 * DRM blob property data for the DP MST path property.
	 */
D
Dave Airlie 已提交
1218 1219
	struct drm_property_blob *path_blob_ptr;

1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
	/**
	 * @tile_blob_ptr:
	 *
	 * DRM blob property data for the tile property (used mostly by DP MST).
	 * This is meant for screens which are driven through separate display
	 * pipelines represented by &drm_crtc, which might not be running with
	 * genlocked clocks. For tiled panels which are genlocked, like
	 * dual-link LVDS or dual-link DSI, the driver should try to not expose
	 * the tiling and virtualize both &drm_crtc and &drm_plane if needed.
	 */
1230 1231
	struct drm_property_blob *tile_blob_ptr;

1232 1233
	uint8_t polled; /* DRM_CONNECTOR_POLL_* */

1234 1235 1236
	/* requested DPMS state */
	int dpms;

1237
	const struct drm_connector_helper_funcs *helper_private;
D
Dave Airlie 已提交
1238

1239
	/* forced on connector */
1240
	struct drm_cmdline_mode cmdline_mode;
1241
	enum drm_connector_force force;
1242
	bool override_edid;
D
Dave Airlie 已提交
1243 1244
	uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER];
	struct drm_encoder *encoder; /* currently active encoder */
1245

1246 1247 1248 1249 1250 1251 1252
	/* 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];
1253
	int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */
1254
	unsigned bad_edid_counter;
1255

1256 1257 1258 1259 1260
	/* 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;

1261
	struct dentry *debugfs_entry;
1262 1263

	struct drm_connector_state *state;
1264 1265 1266 1267 1268 1269 1270 1271 1272

	/* 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;
1273 1274 1275 1276
};

/**
 * struct drm_plane_state - mutable plane state
1277
 * @plane: backpointer to the plane
1278
 * @crtc: currently bound CRTC, NULL if disabled
D
Daniel Vetter 已提交
1279
 * @fb: currently bound framebuffer
1280
 * @fence: optional fence to wait for before scanning out @fb
1281 1282 1283 1284 1285 1286 1287 1288 1289 1290
 * @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)
1291
 * @rotation: rotation of the plane
1292 1293 1294
 * @state: backpointer to global drm_atomic_state
 */
struct drm_plane_state {
1295 1296
	struct drm_plane *plane;

1297 1298
	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() */
1299
	struct fence *fence;
1300 1301 1302 1303 1304 1305 1306 1307 1308

	/* 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;

1309 1310 1311
	/* Plane rotation */
	unsigned int rotation;

1312
	struct drm_atomic_state *state;
D
Dave Airlie 已提交
1313 1314
};

1315

J
Jesse Barnes 已提交
1316
/**
1317
 * struct drm_plane_funcs - driver plane control functions
J
Jesse Barnes 已提交
1318 1319
 */
struct drm_plane_funcs {
1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345
	/**
	 * @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 已提交
1346 1347 1348 1349 1350 1351
	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);
1352 1353 1354 1355 1356

	/**
	 * @disable_plane:
	 *
	 * This is the legacy entry point to disable the plane. The DRM core
1357
	 * calls this method in response to a DRM_IOCTL_MODE_SETPLANE IOCTL call
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
	 * 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 已提交
1368
	int (*disable_plane)(struct drm_plane *plane);
1369 1370 1371 1372 1373 1374 1375 1376

	/**
	 * @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 已提交
1377
	void (*destroy)(struct drm_plane *plane);
1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388

	/**
	 * @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 已提交
1389
	void (*reset)(struct drm_plane *plane);
R
Rob Clark 已提交
1390

1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406
	/**
	 * @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 已提交
1407 1408
	int (*set_property)(struct drm_plane *plane,
			    struct drm_property *property, uint64_t val);
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_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.
	 */
1439
	struct drm_plane_state *(*atomic_duplicate_state)(struct drm_plane *plane);
1440 1441 1442 1443 1444 1445 1446

	/**
	 * @atomic_destroy_state:
	 *
	 * Destroy a state duplicated with @atomic_duplicate_state and release
	 * or unreference all resources it references
	 */
1447
	void (*atomic_destroy_state)(struct drm_plane *plane,
D
Daniel Vetter 已提交
1448
				     struct drm_plane_state *state);
1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491

	/**
	 * @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.
	 */
1492 1493 1494 1495
	int (*atomic_set_property)(struct drm_plane *plane,
				   struct drm_plane_state *state,
				   struct drm_property *property,
				   uint64_t val);
1496 1497 1498 1499 1500

	/**
	 * @atomic_get_property:
	 *
	 * Reads out the decoded driver-private property. This is used to
1501
	 * implement the GETPLANE IOCTL.
1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
	 *
	 * 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 已提交
1515 1516 1517 1518
	int (*atomic_get_property)(struct drm_plane *plane,
				   const struct drm_plane_state *state,
				   struct drm_property *property,
				   uint64_t *val);
J
Jesse Barnes 已提交
1519 1520
};

1521 1522 1523 1524 1525 1526
enum drm_plane_type {
	DRM_PLANE_TYPE_OVERLAY,
	DRM_PLANE_TYPE_PRIMARY,
	DRM_PLANE_TYPE_CURSOR,
};

1527

J
Jesse Barnes 已提交
1528
/**
1529
 * struct drm_plane - central DRM plane control structure
J
Jesse Barnes 已提交
1530 1531
 * @dev: DRM device this plane belongs to
 * @head: for list management
1532
 * @name: human readable name, can be overwritten by the driver
J
Jesse Barnes 已提交
1533 1534 1535 1536
 * @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
1537
 * @format_default: driver hasn't supplied supported formats for the plane
J
Jesse Barnes 已提交
1538 1539
 * @crtc: currently bound CRTC
 * @fb: currently bound fb
D
Daniel Vetter 已提交
1540 1541
 * @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 已提交
1542
 * @funcs: helper functions
R
Rob Clark 已提交
1543
 * @properties: property tracking for this plane
1544
 * @type: type of plane (overlay, primary, cursor)
1545
 * @state: current atomic state for this plane
1546
 * @helper_private: mid-layer private data
J
Jesse Barnes 已提交
1547 1548 1549 1550 1551
 */
struct drm_plane {
	struct drm_device *dev;
	struct list_head head;

1552 1553
	char *name;

1554 1555 1556 1557 1558 1559 1560
	/**
	 * @mutex:
	 *
	 * Protects modeset plane state, together with the mutex of &drm_crtc
	 * this plane is linked to (when active, getting actived or getting
	 * disabled).
	 */
D
Daniel Vetter 已提交
1561 1562
	struct drm_modeset_lock mutex;

J
Jesse Barnes 已提交
1563 1564 1565 1566
	struct drm_mode_object base;

	uint32_t possible_crtcs;
	uint32_t *format_types;
1567
	unsigned int format_count;
1568
	bool format_default;
J
Jesse Barnes 已提交
1569 1570 1571 1572

	struct drm_crtc *crtc;
	struct drm_framebuffer *fb;

1573 1574
	struct drm_framebuffer *old_fb;

J
Jesse Barnes 已提交
1575
	const struct drm_plane_funcs *funcs;
R
Rob Clark 已提交
1576 1577

	struct drm_object_properties properties;
1578 1579

	enum drm_plane_type type;
1580

C
Chris Wilson 已提交
1581 1582 1583
	/* position inside the mode_config.list, can be used as a [] idx */
	unsigned index;

1584
	const struct drm_plane_helper_funcs *helper_private;
D
Daniel Vetter 已提交
1585

1586
	struct drm_plane_state *state;
J
Jesse Barnes 已提交
1587 1588
};

S
Sean Paul 已提交
1589
/**
1590
 * struct drm_bridge_funcs - drm_bridge control functions
1591
 * @attach: Called during drm_bridge_attach
S
Sean Paul 已提交
1592 1593
 */
struct drm_bridge_funcs {
1594
	int (*attach)(struct drm_bridge *bridge);
D
Daniel Vetter 已提交
1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615

	/**
	 * @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
1616
	 * structures except the passed in @state parameter.
D
Daniel Vetter 已提交
1617 1618 1619 1620 1621 1622
	 *
	 * RETURNS:
	 *
	 * True if an acceptable configuration is possible, false if the modeset
	 * operation should be rejected.
	 */
S
Sean Paul 已提交
1623 1624 1625
	bool (*mode_fixup)(struct drm_bridge *bridge,
			   const struct drm_display_mode *mode,
			   struct drm_display_mode *adjusted_mode);
D
Daniel Vetter 已提交
1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637
	/**
	 * @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.
1638 1639
	 *
	 * The disable callback is optional.
D
Daniel Vetter 已提交
1640
	 */
S
Sean Paul 已提交
1641
	void (*disable)(struct drm_bridge *bridge);
D
Daniel Vetter 已提交
1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655

	/**
	 * @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.
1656 1657
	 *
	 * The post_disable callback is optional.
D
Daniel Vetter 已提交
1658
	 */
S
Sean Paul 已提交
1659
	void (*post_disable)(struct drm_bridge *bridge);
D
Daniel Vetter 已提交
1660 1661 1662 1663 1664 1665 1666 1667 1668

	/**
	 * @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 已提交
1669 1670 1671
	void (*mode_set)(struct drm_bridge *bridge,
			 struct drm_display_mode *mode,
			 struct drm_display_mode *adjusted_mode);
D
Daniel Vetter 已提交
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685
	/**
	 * @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.
1686 1687
	 *
	 * The pre_enable callback is optional.
D
Daniel Vetter 已提交
1688
	 */
S
Sean Paul 已提交
1689
	void (*pre_enable)(struct drm_bridge *bridge);
D
Daniel Vetter 已提交
1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704

	/**
	 * @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.
1705 1706
	 *
	 * The enable callback is optional.
D
Daniel Vetter 已提交
1707
	 */
S
Sean Paul 已提交
1708 1709 1710 1711
	void (*enable)(struct drm_bridge *bridge);
};

/**
1712
 * struct drm_bridge - central DRM bridge control structure
S
Sean Paul 已提交
1713
 * @dev: DRM device this bridge belongs to
1714 1715
 * @encoder: encoder to which this bridge is connected
 * @next: the next bridge in the encoder chain
1716 1717
 * @of_node: device node pointer to the bridge
 * @list: to keep track of all added bridges
S
Sean Paul 已提交
1718 1719 1720 1721 1722
 * @funcs: control functions
 * @driver_private: pointer to the bridge driver's internal context
 */
struct drm_bridge {
	struct drm_device *dev;
1723
	struct drm_encoder *encoder;
1724
	struct drm_bridge *next;
1725 1726 1727 1728
#ifdef CONFIG_OF
	struct device_node *of_node;
#endif
	struct list_head list;
S
Sean Paul 已提交
1729 1730 1731 1732 1733

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

1734 1735 1736 1737 1738
struct __drm_planes_state {
	struct drm_plane *ptr;
	struct drm_plane_state *state;
};

1739 1740 1741 1742 1743
struct __drm_crtcs_state {
	struct drm_crtc *ptr;
	struct drm_crtc_state *state;
};

1744 1745 1746 1747 1748
struct __drm_connnectors_state {
	struct drm_connector *ptr;
	struct drm_connector_state *state;
};

D
Daniel Vetter 已提交
1749
/**
R
Rob Clark 已提交
1750
 * struct drm_atomic_state - the global state object for atomic updates
D
Daniel Vetter 已提交
1751
 * @dev: parent DRM device
R
Rob Clark 已提交
1752
 * @allow_modeset: allow full modeset
1753
 * @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics
1754
 * @legacy_set_config: Disable conflicting encoders instead of failing with -EINVAL.
1755
 * @planes: pointer to array of structures with per-plane data
D
Daniel Vetter 已提交
1756
 * @crtcs: pointer to array of CRTC pointers
1757
 * @num_connector: size of the @connectors and @connector_states arrays
1758
 * @connectors: pointer to array of structures with per-connector data
D
Daniel Vetter 已提交
1759 1760 1761 1762
 * @acquire_ctx: acquire context for this atomic modeset state update
 */
struct drm_atomic_state {
	struct drm_device *dev;
R
Rob Clark 已提交
1763
	bool allow_modeset : 1;
1764
	bool legacy_cursor_update : 1;
1765
	bool legacy_set_config : 1;
1766
	struct __drm_planes_state *planes;
1767
	struct __drm_crtcs_state *crtcs;
1768
	int num_connector;
1769
	struct __drm_connnectors_state *connectors;
D
Daniel Vetter 已提交
1770 1771 1772 1773 1774

	struct drm_modeset_acquire_ctx *acquire_ctx;
};


D
Dave Airlie 已提交
1775
/**
1776
 * struct drm_mode_set - new values for a CRTC config change
1777 1778 1779 1780 1781 1782 1783
 * @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 已提交
1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802
 *
 * 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;
};

/**
1803 1804 1805 1806
 * struct drm_mode_config_funcs - basic driver provided mode setting functions
 *
 * Some global (i.e. not per-CRTC, connector, etc) mode setting functions that
 * involve drivers.
D
Dave Airlie 已提交
1807 1808
 */
struct drm_mode_config_funcs {
1809 1810 1811 1812 1813 1814 1815
	/**
	 * @fb_create:
	 *
	 * Create a new framebuffer object. The core does basic checks on the
	 * requested metadata, but most of that is left to the driver. See
	 * struct &drm_mode_fb_cmd2 for details.
	 *
1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826
	 * If the parameters are deemed valid and the backing storage objects in
	 * the underlying memory manager all exist, then the driver allocates
	 * a new &drm_framebuffer structure, subclassed to contain
	 * driver-specific information (like the internal native buffer object
	 * references). It also needs to fill out all relevant metadata, which
	 * should be done by calling drm_helper_mode_fill_fb_struct().
	 *
	 * The initialization is finalized by calling drm_framebuffer_init(),
	 * which registers the framebuffer and makes it accessible to other
	 * threads.
	 *
1827 1828 1829 1830 1831
	 * RETURNS:
	 *
	 * A new framebuffer with an initial reference count of 1 or a negative
	 * error code encoded with ERR_PTR().
	 */
1832 1833
	struct drm_framebuffer *(*fb_create)(struct drm_device *dev,
					     struct drm_file *file_priv,
1834
					     const struct drm_mode_fb_cmd2 *mode_cmd);
1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850

	/**
	 * @output_poll_changed:
	 *
	 * Callback used by helpers to inform the driver of output configuration
	 * changes.
	 *
	 * Drivers implementing fbdev emulation with the helpers can call
	 * drm_fb_helper_hotplug_changed from this hook to inform the fbdev
	 * helper of output changes.
	 *
	 * FIXME:
	 *
	 * Except that there's no vtable for device-level helper callbacks
	 * there's no reason this is a core function.
	 */
1851
	void (*output_poll_changed)(struct drm_device *dev);
D
Daniel Vetter 已提交
1852

1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926
	/**
	 * @atomic_check:
	 *
	 * This is the only hook to validate an atomic modeset update. This
	 * function must reject any modeset and state changes which the hardware
	 * or driver doesn't support. This includes but is of course not limited
	 * to:
	 *
	 *  - Checking that the modes, framebuffers, scaling and placement
	 *    requirements and so on are within the limits of the hardware.
	 *
	 *  - Checking that any hidden shared resources are not oversubscribed.
	 *    This can be shared PLLs, shared lanes, overall memory bandwidth,
	 *    display fifo space (where shared between planes or maybe even
	 *    CRTCs).
	 *
	 *  - Checking that virtualized resources exported to userspace are not
	 *    oversubscribed. For various reasons it can make sense to expose
	 *    more planes, crtcs or encoders than which are physically there. One
	 *    example is dual-pipe operations (which generally should be hidden
	 *    from userspace if when lockstepped in hardware, exposed otherwise),
	 *    where a plane might need 1 hardware plane (if it's just on one
	 *    pipe), 2 hardware planes (when it spans both pipes) or maybe even
	 *    shared a hardware plane with a 2nd plane (if there's a compatible
	 *    plane requested on the area handled by the other pipe).
	 *
	 *  - Check that any transitional state is possible and that if
	 *    requested, the update can indeed be done in the vblank period
	 *    without temporarily disabling some functions.
	 *
	 *  - Check any other constraints the driver or hardware might have.
	 *
	 *  - This callback also needs to correctly fill out the &drm_crtc_state
	 *    in this update to make sure that drm_atomic_crtc_needs_modeset()
	 *    reflects the nature of the possible update and returns true if and
	 *    only if the update cannot be applied without tearing within one
	 *    vblank on that CRTC. The core uses that information to reject
	 *    updates which require a full modeset (i.e. blanking the screen, or
	 *    at least pausing updates for a substantial amount of time) if
	 *    userspace has disallowed that in its request.
	 *
	 *  - The driver also does not need to repeat basic input validation
	 *    like done for the corresponding legacy entry points. The core does
	 *    that before calling this hook.
	 *
	 * See the documentation of @atomic_commit for an exhaustive list of
	 * error conditions which don't have to be checked at the
	 * ->atomic_check() stage?
	 *
	 * See the documentation for struct &drm_atomic_state for how exactly
	 * an atomic modeset update is described.
	 *
	 * Drivers using the atomic helpers can implement this hook using
	 * drm_atomic_helper_check(), or one of the exported sub-functions of
	 * it.
	 *
	 * RETURNS:
	 *
	 * 0 on success or one of the below negative error codes:
	 *
	 *  - -EINVAL, if any of the above constraints are violated.
	 *
	 *  - -EDEADLK, when returned from an attempt to acquire an additional
	 *    &drm_modeset_lock through drm_modeset_lock().
	 *
	 *  - -ENOMEM, if allocating additional state sub-structures failed due
	 *    to lack of memory.
	 *
	 *  - -EINTR, -EAGAIN or -ERESTARTSYS, if the IOCTL should be restarted.
	 *    This can either be due to a pending signal, or because the driver
	 *    needs to completely bail out to recover from an exceptional
	 *    situation like a GPU hang. From a userspace point all errors are
	 *    treated equally.
	 */
D
Daniel Vetter 已提交
1927
	int (*atomic_check)(struct drm_device *dev,
1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
			    struct drm_atomic_state *state);

	/**
	 * @atomic_commit:
	 *
	 * This is the only hook to commit an atomic modeset update. The core
	 * guarantees that @atomic_check has been called successfully before
	 * calling this function, and that nothing has been changed in the
	 * interim.
	 *
	 * See the documentation for struct &drm_atomic_state for how exactly
	 * an atomic modeset update is described.
	 *
	 * Drivers using the atomic helpers can implement this hook using
	 * drm_atomic_helper_commit(), or one of the exported sub-functions of
	 * it.
	 *
1945
	 * Nonblocking commits (as indicated with the nonblock parameter) must
1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957
	 * do any preparatory work which might result in an unsuccessful commit
	 * in the context of this callback. The only exceptions are hardware
	 * errors resulting in -EIO. But even in that case the driver must
	 * ensure that the display pipe is at least running, to avoid
	 * compositors crashing when pageflips don't work. Anything else,
	 * specifically committing the update to the hardware, should be done
	 * without blocking the caller. For updates which do not require a
	 * modeset this must be guaranteed.
	 *
	 * The driver must wait for any pending rendering to the new
	 * framebuffers to complete before executing the flip. It should also
	 * wait for any pending rendering from other drivers if the underlying
1958
	 * buffer is a shared dma-buf. Nonblocking commits must not wait for
1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988
	 * rendering in the context of this callback.
	 *
	 * An application can request to be notified when the atomic commit has
	 * completed. These events are per-CRTC and can be distinguished by the
	 * CRTC index supplied in &drm_event to userspace.
	 *
	 * The drm core will supply a struct &drm_event in the event
	 * member of each CRTC's &drm_crtc_state structure. 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 atomic commit. 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.
	 *
	 * NOTE:
	 *
	 * Drivers are not allowed to shut down any display pipe successfully
	 * enabled through an atomic commit on their own. Doing so can result in
	 * compositors crashing if a page flip is suddenly rejected because the
	 * pipe is off.
	 *
	 * RETURNS:
	 *
	 * 0 on success or one of the below negative error codes:
	 *
1989
	 *  - -EBUSY, if a nonblocking updated is requested and there is
1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
	 *    an earlier updated pending. Drivers are allowed to support a queue
	 *    of outstanding updates, but currently no driver supports that.
	 *    Note that drivers must wait for preceding updates to complete if a
	 *    synchronous update is requested, they are not allowed to fail the
	 *    commit in that case.
	 *
	 *  - -ENOMEM, if the driver failed to allocate memory. Specifically
	 *    this can happen when trying to pin framebuffers, which must only
	 *    be done when committing the state.
	 *
	 *  - -ENOSPC, as a refinement of the more generic -ENOMEM to indicate
	 *    that the driver has run out of vram, iommu space or similar GPU
	 *    address space needed for framebuffer.
	 *
	 *  - -EIO, if the hardware completely died.
	 *
	 *  - -EINTR, -EAGAIN or -ERESTARTSYS, if the IOCTL should be restarted.
	 *    This can either be due to a pending signal, or because the driver
	 *    needs to completely bail out to recover from an exceptional
	 *    situation like a GPU hang. From a userspace point of view all errors are
	 *    treated equally.
	 *
	 * This list is exhaustive. Specifically this hook is not allowed to
	 * return -EINVAL (any invalid requests should be caught in
	 * @atomic_check) or -EDEADLK (this function must not acquire
	 * additional modeset locks).
	 */
D
Daniel Vetter 已提交
2017
	int (*atomic_commit)(struct drm_device *dev,
2018
			     struct drm_atomic_state *state,
2019
			     bool nonblock);
2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032

	/**
	 * @atomic_state_alloc:
	 *
	 * This optional hook can be used by drivers that want to subclass struct
	 * &drm_atomic_state to be able to track their own driver-private global
	 * state easily. If this hook is implemented, drivers must also
	 * implement @atomic_state_clear and @atomic_state_free.
	 *
	 * RETURNS:
	 *
	 * A new &drm_atomic_state on success or NULL on failure.
	 */
2033
	struct drm_atomic_state *(*atomic_state_alloc)(struct drm_device *dev);
2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050

	/**
	 * @atomic_state_clear:
	 *
	 * This hook must clear any driver private state duplicated into the
	 * passed-in &drm_atomic_state. This hook is called when the caller
	 * encountered a &drm_modeset_lock deadlock and needs to drop all
	 * already acquired locks as part of the deadlock avoidance dance
	 * implemented in drm_modeset_lock_backoff().
	 *
	 * Any duplicated state must be invalidated since a concurrent atomic
	 * update might change it, and the drm atomic interfaces always apply
	 * updates as relative changes to the current state.
	 *
	 * Drivers that implement this must call drm_atomic_state_default_clear()
	 * to clear common state.
	 */
2051
	void (*atomic_state_clear)(struct drm_atomic_state *state);
2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062

	/**
	 * @atomic_state_free:
	 *
	 * This hook needs driver private resources and the &drm_atomic_state
	 * itself. Note that the core first calls drm_atomic_state_clear() to
	 * avoid code duplicate between the clear and free hooks.
	 *
	 * Drivers that implement this must call drm_atomic_state_default_free()
	 * to release common resources.
	 */
2063
	void (*atomic_state_free)(struct drm_atomic_state *state);
D
Dave Airlie 已提交
2064 2065 2066
};

/**
D
Daniel Vetter 已提交
2067
 * struct drm_mode_config - Mode configuration control structure
2068
 * @mutex: mutex protecting KMS related lists and structures
D
Daniel Vetter 已提交
2069 2070
 * @connection_mutex: ww mutex protecting connector state and routing
 * @acquire_ctx: global implicit acquire context used by atomic drivers for
2071
 * 	legacy IOCTLs
D
Daniel Vetter 已提交
2072
 * @fb_lock: mutex to protect fb state and lists
2073 2074 2075 2076 2077 2078
 * @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 已提交
2079 2080 2081
 * @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
2082 2083
 * @num_crtc: number of CRTCs on this device
 * @crtc_list: list of CRTC objects
D
Daniel Vetter 已提交
2084
 * @property_list: list of property objects
2085 2086 2087 2088 2089 2090
 * @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 已提交
2091 2092
 * @poll_enabled: track polling support for this device
 * @poll_running: track polling status for this device
2093
 * @delayed_event: track delayed poll uevent deliver for this device
2094
 * @output_poll_work: delayed work for polling in process context
D
Daniel Vetter 已提交
2095
 * @property_blob_list: list of all the blob property objects
D
Daniel Stone 已提交
2096
 * @blob_lock: mutex for blob property allocation and management
2097
 * @*_property: core property tracking
2098 2099 2100 2101 2102 2103 2104 2105 2106
 * @degamma_lut_property: LUT used to convert the framebuffer's colors to linear
 *	gamma
 * @degamma_lut_size_property: size of the degamma LUT as supported by the
 *	driver (read-only)
 * @ctm_property: Matrix used to convert colors after the lookup in the
 *	degamma LUT
 * @gamma_lut_property: LUT used to convert the colors, after the CSC matrix, to
 *	the gamma space of the connected screen (read-only)
 * @gamma_lut_size_property: size of the gamma LUT as supported by the driver
D
Daniel Vetter 已提交
2107 2108 2109 2110 2111
 * @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 已提交
2112
 *
2113 2114 2115
 * 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 已提交
2116 2117
 */
struct drm_mode_config {
J
Jesse Barnes 已提交
2118
	struct mutex mutex; /* protects configuration (mode lists etc.) */
2119 2120
	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() */
2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144

	/**
	 * @idr_mutex:
	 *
	 * Mutex for KMS ID allocation and management. Protects both @crtc_idr
	 * and @tile_idr.
	 */
	struct mutex idr_mutex;

	/**
	 * @crtc_idr:
	 *
	 * Main KMS ID tracking object. Use this idr for all IDs, fb, crtc,
	 * connector, modes - just makes life easier to have only one.
	 */
	struct idr crtc_idr;

	/**
	 * @tile_idr:
	 *
	 * Use this idr for allocating new IDs for tiled sinks like use in some
	 * high-res DP MST screens.
	 */
	struct idr tile_idr;
2145

D
Daniel Vetter 已提交
2146
	struct mutex fb_lock; /* proctects global and per-file fb lists */
D
Dave Airlie 已提交
2147 2148
	int num_fb;
	struct list_head fb_list;
2149

D
Dave Airlie 已提交
2150
	int num_connector;
2151
	struct ida connector_ida;
D
Dave Airlie 已提交
2152 2153 2154
	struct list_head connector_list;
	int num_encoder;
	struct list_head encoder_list;
2155 2156 2157 2158 2159 2160 2161 2162 2163

	/*
	 * 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 已提交
2164
	struct list_head plane_list;
D
Dave Airlie 已提交
2165 2166 2167 2168 2169 2170 2171 2172

	int num_crtc;
	struct list_head crtc_list;

	struct list_head property_list;

	int min_width, min_height;
	int max_width, max_height;
2173
	const struct drm_mode_config_funcs *funcs;
2174
	resource_size_t fb_base;
D
Dave Airlie 已提交
2175

2176 2177
	/* output poll support */
	bool poll_enabled;
2178
	bool poll_running;
2179
	bool delayed_event;
2180
	struct delayed_work output_poll_work;
2181

D
Daniel Stone 已提交
2182 2183
	struct mutex blob_lock;

D
Dave Airlie 已提交
2184 2185 2186 2187
	/* pointers to standard properties */
	struct list_head property_blob_list;
	struct drm_property *edid_property;
	struct drm_property *dpms_property;
D
Dave Airlie 已提交
2188
	struct drm_property *path_property;
2189
	struct drm_property *tile_property;
R
Rob Clark 已提交
2190
	struct drm_property *plane_type_property;
2191
	struct drm_property *rotation_property;
R
Rob Clark 已提交
2192 2193 2194 2195 2196 2197 2198 2199 2200 2201
	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;
2202
	struct drm_property *prop_active;
D
Daniel Stone 已提交
2203
	struct drm_property *prop_mode_id;
D
Dave Airlie 已提交
2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216

	/* 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;
2217 2218 2219
	struct drm_property *tv_brightness_property;
	struct drm_property *tv_contrast_property;
	struct drm_property *tv_flicker_reduction_property;
2220 2221 2222
	struct drm_property *tv_overscan_property;
	struct drm_property *tv_saturation_property;
	struct drm_property *tv_hue_property;
D
Dave Airlie 已提交
2223 2224 2225

	/* Optional properties */
	struct drm_property *scaling_mode_property;
2226
	struct drm_property *aspect_ratio_property;
2227
	struct drm_property *dirty_info_property;
2228

2229 2230 2231 2232 2233 2234 2235
	/* Optional color correction properties */
	struct drm_property *degamma_lut_property;
	struct drm_property *degamma_lut_size_property;
	struct drm_property *ctm_property;
	struct drm_property *gamma_lut_property;
	struct drm_property *gamma_lut_size_property;

2236 2237 2238 2239
	/* properties for virtual machine layout */
	struct drm_property *suggested_x_property;
	struct drm_property *suggested_y_property;

2240 2241
	/* dumb ioctl parameters */
	uint32_t preferred_depth, prefer_shadow;
2242 2243 2244

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

2246 2247 2248 2249 2250
	/**
	 * @allow_fb_modifiers:
	 *
	 * Whether the driver supports fb modifiers in the ADDFB2.1 ioctl call.
	 */
2251 2252
	bool allow_fb_modifiers;

A
Alex Deucher 已提交
2253 2254
	/* cursor size */
	uint32_t cursor_width, cursor_height;
D
Dave Airlie 已提交
2255 2256
};

R
Rob Clark 已提交
2257 2258 2259 2260 2261 2262 2263 2264 2265 2266
/**
 * 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) \
2267
		for_each_if ((plane_mask) & (1 << drm_plane_index(plane)))
R
Rob Clark 已提交
2268

2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279
/**
 * drm_for_each_encoder_mask - iterate over encoders specified by bitmask
 * @encoder: the loop cursor
 * @dev: the DRM device
 * @encoder_mask: bitmask of encoder indices
 *
 * Iterate over all encoders specified by bitmask.
 */
#define drm_for_each_encoder_mask(encoder, dev, encoder_mask) \
	list_for_each_entry((encoder), &(dev)->mode_config.encoder_list, head) \
		for_each_if ((encoder_mask) & (1 << drm_encoder_index(encoder)))
R
Rob Clark 已提交
2280

D
Dave Airlie 已提交
2281 2282 2283 2284 2285 2286 2287
#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 已提交
2288
#define obj_to_plane(x) container_of(x, struct drm_plane, base)
D
Dave Airlie 已提交
2289

2290 2291 2292 2293
struct drm_prop_enum_list {
	int type;
	char *name;
};
D
Dave Airlie 已提交
2294

2295 2296 2297 2298 2299 2300 2301
extern __printf(6, 7)
int drm_crtc_init_with_planes(struct drm_device *dev,
			      struct drm_crtc *crtc,
			      struct drm_plane *primary,
			      struct drm_plane *cursor,
			      const struct drm_crtc_funcs *funcs,
			      const char *name, ...);
D
Dave Airlie 已提交
2302
extern void drm_crtc_cleanup(struct drm_crtc *crtc);
C
Chris Wilson 已提交
2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314

/**
 * drm_crtc_index - find the index of a registered CRTC
 * @crtc: CRTC to find index for
 *
 * Given a registered CRTC, return the index of that CRTC within a DRM
 * device's list of CRTCs.
 */
static inline unsigned int drm_crtc_index(struct drm_crtc *crtc)
{
	return crtc->index;
}
2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326

/**
 * 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 已提交
2327

2328 2329
extern void drm_connector_ida_init(void);
extern void drm_connector_ida_destroy(void);
2330 2331 2332 2333
extern int drm_connector_init(struct drm_device *dev,
			      struct drm_connector *connector,
			      const struct drm_connector_funcs *funcs,
			      int connector_type);
2334 2335
int drm_connector_register(struct drm_connector *connector);
void drm_connector_unregister(struct drm_connector *connector);
D
Dave Airlie 已提交
2336 2337

extern void drm_connector_cleanup(struct drm_connector *connector);
2338 2339 2340 2341 2342
static inline unsigned drm_connector_index(struct drm_connector *connector)
{
	return connector->connector_id;
}

2343 2344
/* helpers to {un}register all connectors from sysfs for device */
extern int drm_connector_register_all(struct drm_device *dev);
2345
extern void drm_connector_unregister_all(struct drm_device *dev);
D
Dave Airlie 已提交
2346

2347 2348 2349 2350
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 已提交
2351

2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362
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);

2363 2364 2365 2366 2367
extern __printf(5, 6)
int drm_encoder_init(struct drm_device *dev,
		     struct drm_encoder *encoder,
		     const struct drm_encoder_funcs *funcs,
		     int encoder_type, const char *name, ...);
C
Chris Wilson 已提交
2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379

/**
 * drm_encoder_index - find the index of a registered encoder
 * @encoder: encoder to find index for
 *
 * Given a registered encoder, return the index of that encoder within a DRM
 * device's list of encoders.
 */
static inline unsigned int drm_encoder_index(struct drm_encoder *encoder)
{
	return encoder->index;
}
D
Dave Airlie 已提交
2380

2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393
/**
 * 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));
}

2394 2395 2396 2397 2398 2399 2400 2401 2402
extern __printf(8, 9)
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,
			     unsigned int format_count,
			     enum drm_plane_type type,
			     const char *name, ...);
J
Jesse Barnes 已提交
2403 2404 2405 2406
extern int drm_plane_init(struct drm_device *dev,
			  struct drm_plane *plane,
			  unsigned long possible_crtcs,
			  const struct drm_plane_funcs *funcs,
2407
			  const uint32_t *formats, unsigned int format_count,
M
Matt Roper 已提交
2408
			  bool is_primary);
J
Jesse Barnes 已提交
2409
extern void drm_plane_cleanup(struct drm_plane *plane);
C
Chris Wilson 已提交
2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421

/**
 * drm_plane_index - find the index of a registered plane
 * @plane: plane to find index for
 *
 * Given a registered plane, return the index of that plane within a DRM
 * device's list of planes.
 */
static inline unsigned int drm_plane_index(struct drm_plane *plane)
{
	return plane->index;
}
2422
extern struct drm_plane * drm_plane_from_index(struct drm_device *dev, int idx);
2423
extern void drm_plane_force_disable(struct drm_plane *plane);
2424 2425
extern int drm_plane_check_pixel_format(const struct drm_plane *plane,
					u32 format);
2426 2427
extern void drm_crtc_get_hv_timing(const struct drm_display_mode *mode,
				   int *hdisplay, int *vdisplay);
2428 2429 2430 2431
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 已提交
2432

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

2435
extern const char *drm_get_connector_status_name(enum drm_connector_status status);
2436
extern const char *drm_get_subpixel_order_name(enum subpixel_order order);
2437 2438 2439 2440 2441
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);
2442
extern void drm_fb_release(struct drm_file *file_priv);
2443 2444
extern void drm_property_destroy_user_blobs(struct drm_device *dev,
                                            struct drm_file *file_priv);
A
Adam Jackson 已提交
2445
extern bool drm_probe_ddc(struct i2c_adapter *adapter);
D
Dave Airlie 已提交
2446 2447
extern struct edid *drm_get_edid(struct drm_connector *connector,
				 struct i2c_adapter *adapter);
2448 2449
extern struct edid *drm_get_edid_switcheroo(struct drm_connector *connector,
					    struct i2c_adapter *adapter);
J
Jani Nikula 已提交
2450
extern struct edid *drm_edid_duplicate(const struct edid *edid);
D
Dave Airlie 已提交
2451 2452
extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid);
extern void drm_mode_config_init(struct drm_device *dev);
2453
extern void drm_mode_config_reset(struct drm_device *dev);
D
Dave Airlie 已提交
2454
extern void drm_mode_config_cleanup(struct drm_device *dev);
2455

D
Dave Airlie 已提交
2456
extern int drm_mode_connector_set_path_property(struct drm_connector *connector,
2457
						const char *path);
2458
int drm_mode_connector_set_tile_property(struct drm_connector *connector);
D
Dave Airlie 已提交
2459
extern int drm_mode_connector_update_edid_property(struct drm_connector *connector,
2460
						   const struct edid *edid);
R
Rob Clark 已提交
2461

2462 2463 2464 2465
extern int drm_display_info_set_bus_formats(struct drm_display_info *info,
					    const u32 *formats,
					    unsigned int num_formats);

R
Rob Clark 已提交
2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481
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);
}

2482 2483 2484 2485 2486 2487
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 已提交
2488 2489 2490
extern int drm_framebuffer_init(struct drm_device *dev,
				struct drm_framebuffer *fb,
				const struct drm_framebuffer_funcs *funcs);
2491 2492
extern struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
						      uint32_t id);
R
Rob Clark 已提交
2493
extern void drm_framebuffer_remove(struct drm_framebuffer *fb);
D
Dave Airlie 已提交
2494
extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb);
2495
extern void drm_framebuffer_unregister_private(struct drm_framebuffer *fb);
D
Dave Airlie 已提交
2496

2497 2498 2499
extern void drm_object_attach_property(struct drm_mode_object *obj,
				       struct drm_property *property,
				       uint64_t init_val);
D
Dave Airlie 已提交
2500 2501
extern struct drm_property *drm_property_create(struct drm_device *dev, int flags,
						const char *name, int num_values);
2502 2503
extern struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags,
					 const char *name,
R
Rob Clark 已提交
2504 2505 2506 2507
					 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,
2508
					 const struct drm_prop_enum_list *props,
2509 2510
					 int num_props,
					 uint64_t supported_bits);
2511 2512 2513
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 已提交
2514 2515 2516
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 已提交
2517 2518
struct drm_property *drm_property_create_object(struct drm_device *dev,
					 int flags, const char *name, uint32_t type);
2519 2520
struct drm_property *drm_property_create_bool(struct drm_device *dev, int flags,
					 const char *name);
2521 2522 2523 2524 2525 2526 2527
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 已提交
2528 2529 2530 2531
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);
2532 2533
extern int drm_mode_create_tv_properties(struct drm_device *dev,
					 unsigned int num_modes,
V
Ville Syrjälä 已提交
2534
					 const char * const modes[]);
D
Dave Airlie 已提交
2535
extern int drm_mode_create_scaling_mode_property(struct drm_device *dev);
2536
extern int drm_mode_create_aspect_ratio_property(struct drm_device *dev);
2537
extern int drm_mode_create_dirty_info_property(struct drm_device *dev);
2538
extern int drm_mode_create_suggested_offset_properties(struct drm_device *dev);
R
Rob Clark 已提交
2539 2540 2541 2542
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 已提交
2543 2544 2545

extern int drm_mode_connector_attach_encoder(struct drm_connector *connector,
					     struct drm_encoder *encoder);
2546
extern int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
D
Dave Airlie 已提交
2547
					 int gamma_size);
2548 2549
extern struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
		uint32_t id, uint32_t type);
2550 2551
void drm_mode_object_reference(struct drm_mode_object *obj);
void drm_mode_object_unreference(struct drm_mode_object *obj);
R
Rob Clark 已提交
2552

D
Dave Airlie 已提交
2553 2554 2555
/* IOCTLs */
extern int drm_mode_getresources(struct drm_device *dev,
				 void *data, struct drm_file *file_priv);
J
Jesse Barnes 已提交
2556 2557
extern int drm_mode_getplane_res(struct drm_device *dev, void *data,
				   struct drm_file *file_priv);
D
Dave Airlie 已提交
2558 2559 2560 2561
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);
2562
extern int drm_mode_set_config_internal(struct drm_mode_set *set);
D
Dave Airlie 已提交
2563 2564
extern int drm_mode_setcrtc(struct drm_device *dev,
			    void *data, struct drm_file *file_priv);
J
Jesse Barnes 已提交
2565 2566 2567 2568
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 已提交
2569 2570
extern int drm_mode_cursor_ioctl(struct drm_device *dev,
				void *data, struct drm_file *file_priv);
2571 2572
extern int drm_mode_cursor2_ioctl(struct drm_device *dev,
				void *data, struct drm_file *file_priv);
D
Dave Airlie 已提交
2573 2574
extern int drm_mode_addfb(struct drm_device *dev,
			  void *data, struct drm_file *file_priv);
2575 2576 2577
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 已提交
2578 2579 2580 2581
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);
2582 2583
extern int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
				  void *data, struct drm_file *file_priv);
D
Dave Airlie 已提交
2584 2585 2586 2587 2588

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);
2589 2590 2591 2592
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 已提交
2593 2594 2595 2596 2597 2598 2599 2600
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);
2601
extern u8 drm_match_cea_mode(const struct drm_display_mode *to_match);
2602
extern enum hdmi_picture_aspect drm_get_cea_aspect_ratio(const u8 video_code);
2603
extern bool drm_detect_hdmi_monitor(struct edid *edid);
2604
extern bool drm_detect_monitor_audio(struct edid *edid);
2605
extern bool drm_rgb_quant_range_selectable(struct edid *edid);
2606 2607
extern int drm_mode_page_flip_ioctl(struct drm_device *dev,
				    void *data, struct drm_file *file_priv);
2608 2609
extern int drm_add_modes_noedid(struct drm_connector *connector,
				int hdisplay, int vdisplay);
G
Gerd Hoffmann 已提交
2610 2611
extern void drm_set_preferred_mode(struct drm_connector *connector,
				   int hpref, int vpref);
2612

2613
extern int drm_edid_header_is_valid(const u8 *raw_edid);
2614 2615
extern bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid,
				 bool *edid_corrupt);
2616
extern bool drm_edid_is_valid(struct edid *edid);
2617 2618
extern void drm_edid_get_monitor_name(struct edid *edid, char *name,
				      int buflen);
D
Dave Airlie 已提交
2619 2620 2621 2622 2623 2624 2625

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 已提交
2626
struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
2627 2628
					   int hsize, int vsize, int fresh,
					   bool rb);
2629 2630 2631 2632 2633 2634 2635

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);
2636 2637 2638 2639
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);
2640 2641 2642
extern int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
				       struct drm_property *property,
				       uint64_t value);
R
Rob Clark 已提交
2643 2644
extern int drm_mode_atomic_ioctl(struct drm_device *dev,
				 void *data, struct drm_file *file_priv);
2645 2646 2647

extern void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
				 int *bpp);
2648
extern int drm_format_num_planes(uint32_t format);
2649
extern int drm_format_plane_cpp(uint32_t format, int plane);
2650 2651
extern int drm_format_horz_chroma_subsampling(uint32_t format);
extern int drm_format_vert_chroma_subsampling(uint32_t format);
2652 2653
extern int drm_format_plane_width(int width, uint32_t format, int plane);
extern int drm_format_plane_height(int height, uint32_t format, int plane);
2654
extern const char *drm_get_format_name(uint32_t format);
2655 2656
extern struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev,
							      unsigned int supported_rotations);
2657 2658
extern unsigned int drm_rotation_simplify(unsigned int rotation,
					  unsigned int supported_rotations);
2659

R
Russell King 已提交
2660
/* Helpers */
R
Rob Clark 已提交
2661 2662 2663 2664 2665 2666 2667 2668 2669

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 已提交
2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685
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;
}

2686 2687 2688 2689 2690 2691 2692 2693 2694
/**
 * drm_connector_lookup - lookup connector object
 * @dev: DRM device
 * @id: connector object id
 *
 * This function looks up the connector object specified by id
 * add takes a reference to it.
 */
static inline struct drm_connector *drm_connector_lookup(struct drm_device *dev,
R
Rob Clark 已提交
2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709
		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;
}

2710 2711 2712 2713 2714 2715 2716
/*
 * Extract a degamma/gamma LUT value provided by user and round it to the
 * precision supported by the hardware.
 */
static inline uint32_t drm_color_lut_extract(uint32_t user_input,
					     uint32_t bit_precision)
{
2717
	uint32_t val = user_input;
2718 2719
	uint32_t max = 0xffff >> (16 - bit_precision);

2720 2721 2722 2723 2724
	/* Round only if we're not using full precision. */
	if (bit_precision < 16) {
		val += 1UL << (16 - bit_precision - 1);
		val >>= 16 - bit_precision;
	}
2725 2726 2727 2728

	return clamp_val(val, 0, max);
}

2729
/**
2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750
 * drm_framebuffer_reference - incr the fb refcnt
 * @fb: framebuffer
 *
 * This functions increments the fb's refcount.
 */
static inline void drm_framebuffer_reference(struct drm_framebuffer *fb)
{
	drm_mode_object_reference(&fb->base);
}

/**
 * drm_framebuffer_unreference - unref a framebuffer
 * @fb: framebuffer to unref
 *
 * This functions decrements the fb's refcount and frees it if it drops to zero.
 */
static inline void drm_framebuffer_unreference(struct drm_framebuffer *fb)
{
	drm_mode_object_unreference(&fb->base);
}

2751 2752 2753 2754 2755 2756 2757 2758
/**
 * drm_framebuffer_read_refcount - read the framebuffer reference count.
 * @fb: framebuffer
 *
 * This functions returns the framebuffer's reference count.
 */
static inline uint32_t drm_framebuffer_read_refcount(struct drm_framebuffer *fb)
{
2759
	return atomic_read(&fb->base.refcount.refcount);
2760 2761
}

2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783
/**
 * drm_connector_reference - incr the connector refcnt
 * @connector: connector
 *
 * This function increments the connector's refcount.
 */
static inline void drm_connector_reference(struct drm_connector *connector)
{
	drm_mode_object_reference(&connector->base);
}

/**
 * drm_connector_unreference - unref a connector
 * @connector: connector to unref
 *
 * This function decrements the connector's refcount and frees it if it drops to zero.
 */
static inline void drm_connector_unreference(struct drm_connector *connector)
{
	drm_mode_object_unreference(&connector->base);
}

2784
/* Plane list iterator for legacy (overlay only) planes. */
2785 2786
#define drm_for_each_legacy_plane(plane, dev) \
	list_for_each_entry(plane, &(dev)->mode_config.plane_list, head) \
2787
		for_each_if (plane->type == DRM_PLANE_TYPE_OVERLAY)
2788

2789 2790 2791 2792 2793 2794
#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)

2795 2796 2797
static inline void
assert_drm_connector_list_read_locked(struct drm_mode_config *mode_config)
{
2798 2799 2800 2801 2802 2803 2804 2805 2806
	/*
	 * 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));
2807 2808
}

2809
#define drm_for_each_connector(connector, dev) \
2810 2811 2812 2813 2814
	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))
2815 2816 2817 2818 2819

#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) \
2820 2821 2822 2823 2824
	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))
2825

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