/* * Copyright (c) 2016 Intel Corporation * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission.  The copyright holders make no representations * about the suitability of this software for any purpose.  It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef __DRM_PLANE_H__#define __DRM_PLANE_H__ #include <linux/list.h>#include <linux/ctype.h>#include <linux/kmsg_dump.h>#include <drm/drm_mode_object.h>#include <drm/drm_color_mgmt.h>#include <drm/drm_rect.h>#include <drm/drm_modeset_lock.h>#include <drm/drm_util.h> struct drm_crtc;struct drm_plane_size_hint;struct drm_printer;struct drm_modeset_acquire_ctx; enum drm_scaling_filter {	DRM_SCALING_FILTER_DEFAULT,	DRM_SCALING_FILTER_NEAREST_NEIGHBOR,}; /** * struct drm_plane_state - mutable plane state * * Please note that the destination coordinates @crtc_x, @crtc_y, @crtc_h and * @crtc_w and the source coordinates @src_x, @src_y, @src_h and @src_w are the * raw coordinates provided by userspace. Drivers should use * drm_atomic_helper_check_plane_state() and only use the derived rectangles in * @src and @dst to program the hardware. */struct drm_plane_state {	/** @plane: backpointer to the plane */	struct drm_plane *plane; 	/**	 * @crtc:	 *	 * Currently bound CRTC, NULL if disabled. Do not write this directly,	 * use drm_atomic_set_crtc_for_plane()	 */	struct drm_crtc *crtc; 	/**	 * @fb:	 *	 * Currently bound framebuffer. Do not write this directly, use	 * drm_atomic_set_fb_for_plane()	 */	struct drm_framebuffer *fb; 	/**	 * @fence:	 *	 * Optional fence to wait for before scanning out @fb. The core atomic	 * code will set this when userspace is using explicit fencing. Do not	 * write this field directly for a driver's implicit fence.	 *	 * Drivers should store any implicit fence in this from their	 * &drm_plane_helper_funcs.prepare_fb callback. See	 * drm_gem_plane_helper_prepare_fb() for a suitable helper.	 */	struct dma_fence *fence; 	/**	 * @crtc_x:	 *	 * Left position of visible portion of plane on crtc, signed dest	 * location allows it to be partially off screen.	 */ 	int32_t crtc_x;	/**	 * @crtc_y:	 *	 * Upper position of visible portion of plane on crtc, signed dest	 * location allows it to be partially off screen.	 */	int32_t crtc_y; 	/** @crtc_w: width of visible portion of plane on crtc */	/** @crtc_h: height of visible portion of plane on crtc */	uint32_t crtc_w, crtc_h; 	/**	 * @src_x: left position of visible portion of plane within plane (in	 * 16.16 fixed point).	 */	uint32_t src_x;	/**	 * @src_y: upper position of visible portion of plane within plane (in	 * 16.16 fixed point).	 */	uint32_t src_y;	/** @src_w: width of visible portion of plane (in 16.16) */	/** @src_h: height of visible portion of plane (in 16.16) */	uint32_t src_h, src_w; 	/** @hotspot_x: x offset to mouse cursor hotspot */	/** @hotspot_y: y offset to mouse cursor hotspot */	int32_t hotspot_x, hotspot_y; 	/**	 * @alpha:	 * Opacity of the plane with 0 as completely transparent and 0xffff as	 * completely opaque. See drm_plane_create_alpha_property() for more	 * details.	 */	u16 alpha; 	/**	 * @pixel_blend_mode:	 * The alpha blending equation selection, describing how the pixels from	 * the current plane are composited with the background. Value can be	 * one of DRM_MODE_BLEND_*	 */	uint16_t pixel_blend_mode; 	/**	 * @rotation:	 * Rotation of the plane. See drm_plane_create_rotation_property() for	 * more details.	 */	unsigned int rotation; 	/**	 * @zpos:	 * Priority of the given plane on crtc (optional).	 *	 * User-space may set mutable zpos properties so that multiple active	 * planes on the same CRTC have identical zpos values. This is a	 * user-space bug, but drivers can solve the conflict by comparing the	 * plane object IDs; the plane with a higher ID is stacked on top of a	 * plane with a lower ID.	 *	 * See drm_plane_create_zpos_property() and	 * drm_plane_create_zpos_immutable_property() for more details.	 */	unsigned int zpos; 	/**	 * @normalized_zpos:	 * Normalized value of zpos: unique, range from 0 to N-1 where N is the	 * number of active planes for given crtc. Note that the driver must set	 * &drm_mode_config.normalize_zpos or call drm_atomic_normalize_zpos() to	 * update this before it can be trusted.	 */	unsigned int normalized_zpos; 	/**	 * @color_encoding:	 *	 * Color encoding for non RGB formats	 */	enum drm_color_encoding color_encoding; 	/**	 * @color_range:	 *	 * Color range for non RGB formats	 */	enum drm_color_range color_range; 	/**	 * @fb_damage_clips:	 *	 * Blob representing damage (area in plane framebuffer that changed	 * since last plane update) as an array of &drm_mode_rect in framebuffer	 * coodinates of the attached framebuffer. Note that unlike plane src,	 * damage clips are not in 16.16 fixed point.	 *	 * See drm_plane_get_damage_clips() and	 * drm_plane_get_damage_clips_count() for accessing these.	 */	struct drm_property_blob *fb_damage_clips; 	/**	 * @ignore_damage_clips:	 *	 * Set by drivers to indicate the drm_atomic_helper_damage_iter_init()	 * helper that the @fb_damage_clips blob property should be ignored.	 *	 * See :ref:`damage_tracking_properties` for more information.	 */	bool ignore_damage_clips; 	/**	 * @src:	 *	 * source coordinates of the plane (in 16.16).	 *	 * When using drm_atomic_helper_check_plane_state(),	 * the coordinates are clipped, but the driver may choose	 * to use unclipped coordinates instead when the hardware	 * performs the clipping automatically.	 */	/**	 * @dst:	 *	 * clipped destination coordinates of the plane.	 *	 * When using drm_atomic_helper_check_plane_state(),	 * the coordinates are clipped, but the driver may choose	 * to use unclipped coordinates instead when the hardware	 * performs the clipping automatically.	 */	struct drm_rect src, dst; 	/**	 * @visible:	 *	 * Visibility of the plane. This can be false even if fb!=NULL and	 * crtc!=NULL, due to clipping.	 */	bool visible; 	/**	 * @scaling_filter:	 *	 * Scaling filter to be applied	 */	enum drm_scaling_filter scaling_filter; 	/**	 * @color_pipeline:	 *	 * The first colorop of the active color pipeline, or NULL, if no	 * color pipeline is active.	 */	struct drm_colorop *color_pipeline; 	/**	 * @commit: Tracks the pending commit to prevent use-after-free conditions,	 * and for async plane updates.	 *	 * May be NULL.	 */	struct drm_crtc_commit *commit; 	/** @state: backpointer to global drm_atomic_commit */	struct drm_atomic_commit *state; 	/**	 * @color_mgmt_changed: Color management properties have changed. Used	 * by the atomic helpers and drivers to steer the atomic commit control	 * flow.	 */	bool color_mgmt_changed : 1;}; static inline struct drm_rectdrm_plane_state_src(const struct drm_plane_state *state){	struct drm_rect src = {		.x1 = state->src_x,		.y1 = state->src_y,		.x2 = state->src_x + state->src_w,		.y2 = state->src_y + state->src_h,	};	return src;} static inline struct drm_rectdrm_plane_state_dest(const struct drm_plane_state *state){	struct drm_rect dest = {		.x1 = state->crtc_x,		.y1 = state->crtc_y,		.x2 = state->crtc_x + state->crtc_w,		.y2 = state->crtc_y + state->crtc_h,	};	return dest;} /** * struct drm_plane_funcs - driver plane control functions */struct drm_plane_funcs {	/**	 * @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.	 */	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,			    struct drm_modeset_acquire_ctx *ctx); 	/**	 * @disable_plane:	 *	 * This is the legacy entry point to disable the plane. The DRM core	 * calls this method in response to a DRM_IOCTL_MODE_SETPLANE IOCTL call	 * 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.	 */	int (*disable_plane)(struct drm_plane *plane,			     struct drm_modeset_acquire_ctx *ctx); 	/**	 * @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.	 */	void (*destroy)(struct drm_plane *plane); 	/**	 * @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.	 */	void (*reset)(struct drm_plane *plane); 	/**	 * @set_property:	 *	 * This is the legacy entry point to update a property attached to the	 * plane.	 *	 * This callback is optional if the driver does not support any legacy	 * driver-private properties. For atomic drivers it is not used because	 * property handling is done entirely in the DRM core.	 *	 * RETURNS:	 *	 * 0 on success or a negative error code on failure.	 */	int (*set_property)(struct drm_plane *plane,			    struct drm_property *property, uint64_t val); 	/**	 * @atomic_create_state:	 *	 * Allocate a pristine, initialized, state for the plane object	 * and return it. This callback must have no side effects: in	 * particular, the returned state must not be assigned to the	 * object's state pointer and it must not affect the hardware	 * state.	 *	 * RETURNS:	 *	 * A new, pristine, plane state instance or an error pointer	 * on failure.	 */	struct drm_plane_state *(*atomic_create_state)(struct drm_plane *plane); 	/**	 * @atomic_duplicate_state:	 *	 * Duplicate the current atomic state for this plane and return it.	 * The core and helpers guarantee that any atomic state duplicated with	 * this hook and still owned by the caller (i.e. not transferred to the	 * driver by calling &drm_mode_config_funcs.atomic_commit) will be	 * cleaned up by calling the @atomic_destroy_state hook in this	 * structure.	 *	 * This callback is mandatory for atomic drivers.	 *	 * 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 &drm_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.	 */	struct drm_plane_state *(*atomic_duplicate_state)(struct drm_plane *plane); 	/**	 * @atomic_destroy_state:	 *	 * Destroy a state duplicated with @atomic_duplicate_state and release	 * or unreference all resources it references	 *	 * This callback is mandatory for atomic drivers.	 */	void (*atomic_destroy_state)(struct drm_plane *plane,				     struct drm_plane_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_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.	 */	int (*atomic_set_property)(struct drm_plane *plane,				   struct drm_plane_state *state,				   struct drm_property *property,				   uint64_t val); 	/**	 * @atomic_get_property:	 *

Lines 1–500 of 1044. Load more