Subversion Repositories Kolibri OS

/*

 * Copyright © 2006 Keith Packard

 * Copyright © 2007-2008 Dave Airlie

 * Copyright © 2007-2008 Intel Corporation

 *   Jesse Barnes 

 *

 * 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 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

struct drm_device;

struct drm_mode_set;

struct drm_framebuffer;

struct drm_object_properties;

struct drm_file;

struct drm_clip_rect;

struct device_node;

struct fence;

#define DRM_MODE_OBJECT_CRTC 0xcccccccc

#define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0

#define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0

#define DRM_MODE_OBJECT_MODE 0xdededede

#define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0

#define DRM_MODE_OBJECT_FB 0xfbfbfbfb

#define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb

#define DRM_MODE_OBJECT_PLANE 0xeeeeeeee

#define DRM_MODE_OBJECT_ANY 0

struct drm_mode_object {

	uint32_t id;

	uint32_t type;

	struct drm_object_properties *properties;

};

#define DRM_OBJECT_MAX_PROPERTY 24

struct drm_object_properties {

	int count, atomic_count;

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

	/* do not read/write values directly, but use drm_object_property_get_value()

	 * and drm_object_property_set_value():

	 */

	uint64_t values[DRM_OBJECT_MAX_PROPERTY];

};

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);

}

/*

 * Rotation property bits. DRM_ROTATE_ 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

 */

#define DRM_ROTATE_MASK 0x0f

#define DRM_ROTATE_0	0

#define DRM_ROTATE_90	1

#define DRM_ROTATE_180	2

#define DRM_ROTATE_270	3

#define DRM_REFLECT_MASK (~DRM_ROTATE_MASK)

#define DRM_REFLECT_X	4

#define DRM_REFLECT_Y	5

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

};

#include 

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,

};

#define DRM_COLOR_FORMAT_RGB444		(1<<0)

#define DRM_COLOR_FORMAT_YCRCB444	(1<<1)

#define DRM_COLOR_FORMAT_YCRCB422	(1<<2)

/*

 * Describes a given display (e.g. CRT or flat panel) and its limitations.

 */

struct drm_display_info {

	char name[DRM_DISPLAY_INFO_LEN];

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

	unsigned int bpc;

	enum subpixel_order subpixel_order;

	u32 color_formats;

	const u32 *bus_formats;

	unsigned int num_bus_formats;

	/* Mask of supported hdmi deep color modes */

	u8 edid_hdmi_dc_modes;

	u8 cea_rev;

};

/* data corresponds to displayid vend/prod/serial */

struct drm_tile_group {

	struct kref refcount;

	struct drm_device *dev;

	int id;

	u8 group_data[8];

};

/**

 * struct drm_framebuffer_funcs - framebuffer hooks

 */

struct drm_framebuffer_funcs {

	/**

	 * @destroy:

	 *

	 * Clean up framebuffer resources, specifically also unreference the

	 * backing storage. The core guarantees to call this function for every

	 * framebuffer successfully created by ->fb_create() in

	 * &drm_mode_config_funcs. Drivers must also call

	 * drm_framebuffer_cleanup() to release DRM core resources for this

	 * framebuffer.

	 */

	void (*destroy)(struct drm_framebuffer *framebuffer);

	/**

	 * @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.

	 *

	 * GEM based drivers should call drm_gem_handle_create() to create the

	 * handle.

	 *

	 * RETURNS:

	 *

	 * 0 on success or a negative error code on failure.

	 */

	int (*create_handle)(struct drm_framebuffer *fb,

			     struct drm_file *file_priv,

			     unsigned int *handle);

	/**

	 * @dirty:

	 *

	 * Optional callback for the dirty fb IOCTL.

	 *

	 * 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.

	 */

	int (*dirty)(struct drm_framebuffer *framebuffer,

		     struct drm_file *file_priv, unsigned flags,

		     unsigned color, struct drm_clip_rect *clips,

		     unsigned num_clips);

};

struct drm_framebuffer {

	struct drm_device *dev;

	/*

	 * Note that the fb is refcounted for the benefit of driver internals,

	 * for example some hw, disabling a CRTC/plane is asynchronous, and

	 * scanout does not actually complete until the next vblank.  So some

	 * cleanup (like releasing the reference(s) on the backing GEM bo(s))

	 * should be deferred.  In cases like this, the driver would like to

	 * hold a ref to the fb even though it has already been removed from

	 * userspace perspective.

	 */

	struct kref refcount;

	/*

	 * Place on the dev->mode_config.fb_list, access protected by

	 * dev->mode_config.fb_lock.

	 */

	struct list_head head;

	struct drm_mode_object base;

	const struct drm_framebuffer_funcs *funcs;

	unsigned int pitches[4];

	unsigned int offsets[4];

	uint64_t modifier[4];

	unsigned int width;

	unsigned int height;

	/* depth can be 15 or 16 */

	unsigned int depth;

	int bits_per_pixel;

	int flags;

	uint32_t pixel_format; /* fourcc format */

	struct list_head filp_head;

};

struct drm_property_blob {

	struct drm_mode_object base;

	struct drm_device *dev;

	struct kref refcount;

	struct list_head head_global;

	struct list_head head_file;

	size_t length;

	unsigned char data[];

};

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;

	struct drm_device *dev;

	struct list_head enum_list;

};

struct drm_crtc;

struct drm_connector;

struct drm_encoder;

struct drm_pending_vblank_event;

struct drm_plane;

struct drm_bridge;

struct drm_atomic_state;

struct drm_crtc_helper_funcs;

struct drm_encoder_helper_funcs;

struct drm_connector_helper_funcs;

struct drm_plane_helper_funcs;

/**

 * struct drm_crtc_state - mutable CRTC state

 * @crtc: backpointer to the CRTC

 * @enable: whether the CRTC should be enabled, gates all other state

 * @active: whether the CRTC is actively displaying (used for DPMS)

 * @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

 * @color_mgmt_changed: color management properties have changed (degamma or

 *	gamma LUT or CSC matrix)

 * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes

 * @connector_mask: bitmask of (1 << drm_connector_index(connector)) of attached connectors

 * @encoder_mask: bitmask of (1 << drm_encoder_index(encoder)) of attached encoders

 * @last_vblank_count: for helpers and drivers to capture the vblank of the

 * 	update to ensure framebuffer cleanup isn't done too early

 * @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings

 * @mode: current mode timings

 * @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

 * @event: optional pointer to a DRM event to signal upon completion of the

 * 	state update

 * @state: backpointer to global drm_atomic_state

 *

 * 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.

 */

struct drm_crtc_state {

	struct drm_crtc *crtc;

	bool enable;

	bool active;

	/* computed state bits used by helpers and drivers */

	bool planes_changed : 1;

	bool mode_changed : 1;

	bool active_changed : 1;

	bool connectors_changed : 1;

	bool color_mgmt_changed : 1;

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

	u32 connector_mask;

	u32 encoder_mask;

	/* last_vblank_count: for vblank waits before cleanup */

	u32 last_vblank_count;

	/* adjusted_mode: for use by helpers and drivers */

	struct drm_display_mode adjusted_mode;

	struct drm_display_mode mode;

	/* blob property to expose current mode to atomic userspace */

	struct drm_property_blob *mode_blob;

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

	struct drm_pending_vblank_event *event;

	struct drm_atomic_state *state;

};

/**

 * struct drm_crtc_funcs - control CRTCs for a given device

 *

 * 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 {

	/**

	 * @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.

	 */

	void (*reset)(struct drm_crtc *crtc);

	/**

	 * @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.

	 */

	int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv,

			  uint32_t handle, uint32_t width, uint32_t height);

	/**

	 * @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.

	 */

	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);

	/**

	 * @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.

	 */

	int (*cursor_move)(struct drm_crtc *crtc, int x, int y);

	/**

	 * @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.

	 */

	void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,

			  uint32_t start, uint32_t size);

	/**

	 * @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.

	 */

	void (*destroy)(struct drm_crtc *crtc);

	/**

	 * @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.

	 */

	int (*set_config)(struct drm_mode_set *set);

	/**

	 * @page_flip:

	 *

	 * Legacy entry point to schedule a flip to the given framebuffer.

	 *

	 * Page flipping is a synchronization mechanism that replaces the frame

	 * buffer being scanned out by the CRTC with a new frame buffer during

	 * vertical blanking, avoiding tearing (except when requested otherwise

	 * through the DRM_MODE_PAGE_FLIP_ASYNC flag). When an application

	 * requests a page flip the DRM core verifies that the new frame buffer

	 * is large enough to be scanned out by the CRTC in the currently

	 * configured mode and then calls the CRTC ->page_flip() operation with a

	 * pointer to the new frame buffer.

	 *

	 * The driver must wait for any pending rendering to the new framebuffer

	 * to complete before executing the flip. It should also wait for any

	 * pending rendering from other drivers if the underlying buffer is a

	 * shared dma-buf.

	 *

	 * An application can request to be notified when the page flip has

	 * completed. The drm core will supply a struct &drm_event in the event

	 * parameter in this case. This can be handled by the

	 * drm_crtc_send_vblank_event() function, which the driver should call on

	 * the provided event upon completion of the flip. Note that if

	 * the driver supports vblank signalling and timestamping the vblank

	 * counters and timestamps must agree with the ones returned from page

	 * flip events. With the current vblank helper infrastructure this can

	 * be achieved by holding a vblank reference while the page flip is

	 * pending, acquired through drm_crtc_vblank_get() and released with

	 * drm_crtc_vblank_put(). Drivers are free to implement their own vblank

	 * counter and timestamp tracking though, e.g. if they have accurate

	 * timestamp registers in hardware.

	 *

	 * FIXME:

	 *

	 * Up to that point drivers need to manage events themselves and can use

	 * even->base.list freely for that. Specifically they need to ensure

	 * that they don't send out page flip (or vblank) events for which the

	 * corresponding drm file has been closed already. The drm core

	 * unfortunately does not (yet) take care of that. Therefore drivers

	 * currently must clean up and release pending events in their

	 * ->preclose driver function.

	 *

	 * This callback is optional.

	 *

	 * NOTE:

	 *

	 * Very early versions of the KMS ABI mandated that the driver must

	 * block (but not reject) any rendering to the old framebuffer until the

	 * flip operation has completed and the old framebuffer is no longer

	 * visible. This requirement has been lifted, and userspace is instead

	 * expected to request delivery of an event and wait with recycling old

	 * buffers until such has been received.

	 *

	 * RETURNS:

	 *

	 * 0 on success or a negative error code on failure. Note that if a

	 * ->page_flip() operation is already pending the callback should return

	 * -EBUSY. Pageflips on a disabled CRTC (either by setting a NULL mode

	 * or just runtime disabled through DPMS respectively the new atomic

	 * "ACTIVE" state) should result in an -EINVAL error code. Note that

	 * drm_atomic_helper_page_flip() checks this already for atomic drivers.

	 */

	int (*page_flip)(struct drm_crtc *crtc,

			 struct drm_framebuffer *fb,

			 struct drm_pending_vblank_event *event,

			 uint32_t flags);

	/**

	 * @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.

	 */

	int (*set_property)(struct drm_crtc *crtc,

			    struct drm_property *property, uint64_t val);

	/**

	 * @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.

	 */

	struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc);

	/**

	 * @atomic_destroy_state:

	 *

	 * Destroy a state duplicated with @atomic_duplicate_state and release

	 * or unreference all resources it references

	 */

	void (*atomic_destroy_state)(struct drm_crtc *crtc,

				     struct drm_crtc_state *state);

	/**

	 * @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.

	 */

	int (*atomic_set_property)(struct drm_crtc *crtc,

				   struct drm_crtc_state *state,

				   struct drm_property *property,

				   uint64_t val);

	/**

	 * @atomic_get_property:

	 *

	 * Reads out the decoded driver-private property. This is used to

	 * implement the GETCRTC IOCTL.

	 *

	 * 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).

	 */

	int (*atomic_get_property)(struct drm_crtc *crtc,

				   const struct drm_crtc_state *state,

				   struct drm_property *property,

				   uint64_t *val);

};

/**

 * struct drm_crtc - central CRTC control structure

 * @dev: parent DRM device

 * @port: OF node used by drm_of_find_possible_crtcs()

 * @head: list management

 * @mutex: per-CRTC locking

 * @base: base KMS object for ID tracking etc.

 * @primary: primary plane for this CRTC

 * @cursor: cursor plane for this CRTC

 * @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

 * @enabled: is this CRTC enabled?

 * @mode: current mode timings

 * @hwmode: mode timings as programmed to hw regs

 * @x: x position on screen

 * @y: y position on screen

 * @funcs: CRTC control functions

 * @gamma_size: size of gamma ramp

 * @gamma_store: gamma ramp values

 * @helper_private: mid-layer private data

 * @properties: property tracking for this CRTC

 * @state: current atomic state for this CRTC

 * @acquire_ctx: per-CRTC implicit acquire context used by atomic drivers for

 * 	legacy IOCTLs

 *

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

	struct device_node *port;

	struct list_head head;

	char *name;

	/*

	 * crtc mutex

	 *

	 * This provides a read lock for the overall crtc state (mode, dpms

	 * state, ...) and a write lock for everything which can be update

	 * without a full modeset (fb, cursor data, ...)

	 */

	struct drm_modeset_lock mutex;

	struct drm_mode_object base;

	/* primary and cursor planes for CRTC */

	struct drm_plane *primary;

	struct drm_plane *cursor;

	/* position of cursor plane on crtc */

	int cursor_x;

	int cursor_y;

	bool enabled;

	/* Requested mode from modesetting. */

	struct drm_display_mode mode;

	/* Programmed mode in hw, after adjustments for encoders,

	 * crtc, panel scaling etc. Needed for timestamping etc.

	 */

	struct drm_display_mode hwmode;

	int x, y;

	const struct drm_crtc_funcs *funcs;

	/* Legacy FB CRTC gamma size for reporting to userspace */

	uint32_t gamma_size;

	uint16_t *gamma_store;

	/* if you are using the helper */

	const struct drm_crtc_helper_funcs *helper_private;

	struct drm_object_properties properties;

	struct drm_crtc_state *state;

	/*

	 * For legacy crtc IOCTLs so that atomic drivers can get at the locking

	 * acquire context.

	 */

	struct drm_modeset_acquire_ctx *acquire_ctx;

};

/**

 * struct drm_connector_state - mutable connector state

 * @connector: backpointer to the connector

 * @crtc: CRTC to connect connector to, NULL if disabled

 * @best_encoder: can be used by helpers and drivers to select the encoder

 * @state: backpointer to global drm_atomic_state

 */

struct drm_connector_state {

	struct drm_connector *connector;

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

	struct drm_encoder *best_encoder;

	struct drm_atomic_state *state;

};

/**

 * struct drm_connector_funcs - control connectors on a given device

 *

 * 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 {

	/**

	 * @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.

	 */

	int (*dpms)(struct drm_connector *connector, int mode);

	/**

	 * @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.

	 */

	void (*reset)(struct drm_connector *connector);

	/**

	 * @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.

	 */

	enum drm_connector_status (*detect)(struct drm_connector *connector,

					    bool force);

	/**

	 * @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.

	 */

	int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height);

	/**

	 * @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.

	 */

	int (*set_property)(struct drm_connector *connector, struct drm_property *property,

			     uint64_t val);

	/**

	 * @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).

	 */

	void (*destroy)(struct drm_connector *connector);

	/**

	 * @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.

	 */

	struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector);

	/**

	 * @atomic_destroy_state:

	 *

	 * Destroy a state duplicated with @atomic_duplicate_state and release

	 * or unreference all resources it references

	 */

	void (*atomic_destroy_state)(struct drm_connector *connector,

				     struct drm_connector_state *state);

	/**

	 * @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.

	 */

	int (*atomic_set_property)(struct drm_connector *connector,

				   struct drm_connector_state *state,

				   struct drm_property *property,

				   uint64_t val);

	/**

	 * @atomic_get_property:

	 *

	 * Reads out the decoded driver-private property. This is used to

	 * implement the GETCONNECTOR IOCTL.

	 *

	 * 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).

	 */

	int (*atomic_get_property)(struct drm_connector *connector,

				   const struct drm_connector_state *state,

				   struct drm_property *property,

				   uint64_t *val);

};

/**

 * struct drm_encoder_funcs - encoder controls

 *

 * Encoders sit between CRTCs and connectors.

 */

struct drm_encoder_funcs {

	/**

	 * @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.

	 */

	void (*reset)(struct drm_encoder *encoder);

	/**

	 * @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.

	 */

	void (*destroy)(struct drm_encoder *encoder);

};

#define DRM_CONNECTOR_MAX_ENCODER 3

/**

 * struct drm_encoder - central DRM encoder structure

 * @dev: parent DRM device

 * @head: list management

 * @base: base KMS object

 * @name: encoder name

 * @encoder_type: one of the %DRM_MODE_ENCODER_ 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

 * @bridge: bridge associated to the encoder

 * @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.

 */

struct drm_encoder {

	struct drm_device *dev;