#ifndef _MSM_MDP_EXT_H_
#define _MSM_MDP_EXT_H_
#include <linux/msm_mdp.h>
#define MDP_IOCTL_MAGIC 'S'
/* atomic commit ioctl used for validate and commit request */
#define MSMFB_ATOMIC_COMMIT _IOWR(MDP_IOCTL_MAGIC, 128, void *)
/*
* Ioctl for updating the layer position asynchronously. Initially, pipes
* should be configured with MDP_LAYER_ASYNC flag set during the atomic commit,
* after which any number of position update calls can be made. This would
* enable multiple position updates within a single vsync. However, the screen
* update would happen only after vsync, which would pick the latest update.
*
* Limitations:
* - Currently supported only for video mode panels with single LM or dual LM
* with source_split enabled.
* - Only position update is supported with no scaling/cropping.
* - Async layers should have unique z_order.
*/
#define MSMFB_ASYNC_POSITION_UPDATE _IOWR(MDP_IOCTL_MAGIC, 129, \
struct mdp_position_update)
/**********************************************************************
LAYER FLAG CONFIGURATION
**********************************************************************/
/* left-right layer flip flag */
#define MDP_LAYER_FLIP_LR 0x1
/* up-down layer flip flag */
#define MDP_LAYER_FLIP_UD 0x2
/*
* This flag enables pixel extension for the current layer. Validate/commit
* call uses scale parameters when this flag is enabled.
*/
#define MDP_LAYER_ENABLE_PIXEL_EXT 0x4
/* Flag indicates that layer is foreground layer */
#define MDP_LAYER_FORGROUND 0x8
/* Flag indicates that layer is associated with secure session */
#define MDP_LAYER_SECURE_SESSION 0x10
/*
* Flag indicates that layer is drawing solid fill. Validate/commit call
* does not expect buffer when this flag is enabled.
*/
#define MDP_LAYER_SOLID_FILL 0x20
/* Layer format is deinterlace */
#define MDP_LAYER_DEINTERLACE 0x40
/* layer contains bandwidth compressed format data */
#define MDP_LAYER_BWC 0x80
/* layer is async position updatable */
#define MDP_LAYER_ASYNC 0x100
/* layer contains postprocessing configuration data */
#define MDP_LAYER_PP 0x200
/* Flag indicates that layer is associated with secure display session */
#define MDP_LAYER_SECURE_DISPLAY_SESSION 0x400
/**********************************************************************
VALIDATE/COMMIT FLAG CONFIGURATION
**********************************************************************/
/*
* Client enables it to inform that call is to validate layers before commit.
* If this flag is not set then driver will use MSMFB_ATOMIC_COMMIT for commit.
*/
#define MDP_VALIDATE_LAYER 0x01
/*
* This flag is only valid for commit call. Commit behavior is synchronous
* when this flag is defined. It blocks current call till processing is
* complete. Behavior is asynchronous otherwise.
*/
#define MDP_COMMIT_WAIT_FOR_FINISH 0x02
/*
* This flag is only valid for commit call and used for debugging purpose. It
* forces the to wait for sync fences.
*/
#define MDP_COMMIT_SYNC_FENCE_WAIT 0x04
#define MDP_COMMIT_VERSION_1_0 0x00010000
/**********************************************************************
Configuration structures
All parameters are input to driver unless mentioned output parameter
explicitly.
**********************************************************************/
struct mdp_layer_plane {
/* DMA buffer file descriptor information. */
int fd;
/* Pixel offset in the dma buffer. */
uint32_t offset;
/* Number of bytes in one scan line including padding bytes. */
uint32_t stride;
};
struct mdp_layer_buffer {
/* layer width in pixels. */
uint32_t width;
/* layer height in pixels. */
uint32_t height;
/*
* layer format in DRM-style fourcc, refer drm_fourcc.h for
* standard formats
*/
uint32_t format;
/* plane to hold the fd, offset, etc for all color components */
struct mdp_layer_plane planes[MAX_PLANES];
/* valid planes count in layer planes list */
uint32_t plane_count;
/* compression ratio factor, value depends on the pixel format */
struct mult_factor comp_ratio;
/*
* SyncFence associated with this buffer. It is used in two ways.
*
* 1. Driver waits to consume the buffer till producer signals in case
* of primary and external display.
*
* 2. Writeback device uses buffer structure for output buffer where
* driver is producer. However, client sends the fence with buffer to
* indicate that consumer is still using the buffer and it is not ready
* for new content.
*/
int fence;
/* 32bits reserved value for future usage. */
uint32_t reserved;
};
/*
* One layer holds configuration for one pipe. If client wants to stage single
* layer on two pipes then it should send two different layers with relative
* (x,y) information. Client must send same information during validate and
* commit call. Commit call may fail if client sends different layer information
* attached to same pipe during validate and commit. Device invalidate the pipe
* once it receives the vsync for that commit.
*/
struct mdp_input_layer {
/*
* Flag to enable/disable properties for layer configuration. Refer
* layer flag configuration section for all possible flags.
*/
uint32_t flags;
/*
* Pipe selection for this layer by client. Client provides the index
* in validate and commit call. Device reserves the pipe once validate
* is successful. Device only uses validated pipe during commit call.
* If client sends different layer/pipe configuration in validate &
* commit then commit may fail.
*/
uint32_t pipe_ndx;
/*
* Horizontal decimation value, this indicates the amount of pixels
* dropped for each pixel that is fetched from a line. It does not
* result in bandwidth reduction because pixels are still fetched from
* memory but dropped internally by hardware.
* The decimation value given should be power of two of decimation
* amount.
* 0: no decimation
* 1: decimate by 2 (drop 1 pixel for each pixel fetched)
* 2: decimate by 4 (drop 3 pixels for each pixel fetched)
* 3: decimate by 8 (drop 7 pixels for each pixel fetched)
* 4: decimate by 16 (drop 15 pixels for each pixel fetched)
*/
uint8_t horz_deci;
/*
* Vertical decimation value, this indicates the amount of lines
* dropped for each line that is fetched from overlay. It saves
* bandwidth because decimated pixels are not fetched.
* The decimation value given should be power of two of decimation
* amount.
* 0: no decimation
* 1: decimation by 2 (drop 1 line for each line fetched)
* 2: decimation by 4 (drop 3 lines for each line fetched)
* 3: decimation by 8 (drop 7 lines for each line fetched)
* 4: decimation by 16 (drop 15 lines for each line fetched)
*/
uint8_t vert_deci;
/*
* Used to set plane opacity. The range can be from 0-255, where
* 0 means completely transparent and 255 means fully opaque.
*/
uint8_t alpha;
/*
* Blending stage to occupy in display, if multiple layers are present,
* highest z_order usually means the top most visible layer. The range
* acceptable is from 0-7 to support blending up to 8 layers.
*/
uint16_t z_order;
/*
* Color used as color key for transparency. Any pixel in fetched
* image matching this color will be transparent when blending.
* The color should be in same format as the source image format.
*/
uint32_t transp_mask;
/*
* Solid color used to fill the overlay surface when no source
* buffer is provided.
*/
uint32_t bg_color;
/* blend operation defined in "mdss_mdp_blend_op" enum. */
enum mdss_mdp_blend_op blend_op;
/* color space of the source */
enum mdp_color_space color_space;
/*
* Source crop rectangle, portion of image that will be fetched. This
* should always be within boundaries of source image.
*/
struct mdp_rect src_rect;
/*
* Destination rectangle, the position and size of image on screen.
* This should always be within panel boundaries.
*/
struct mdp_rect dst_rect;
/* Scaling parameters. */
struct mdp_scale_data __user *scale;
/* Buffer attached with each layer. Device uses it for commit call. */
struct mdp_layer_buffer buffer;
/*
* Source side post processing configuration information for each
* layer.
*/
void __user *pp_info;
/*
* This is an output parameter.
*
* Only for validate call. Frame buffer device sets error code
* based on validate call failure scenario.
*/
int error_code;
/* 32bits reserved value for future usage. */
uint32_t reserved[6];
};
struct mdp_output_layer {
/*
* Flag to enable/disable properties for layer configuration. Refer
* layer flag config section for all possible flags.
*/
uint32_t flags;
/*
* Writeback destination selection for output. Client provides the index
* in validate and commit call.
*/
uint32_t writeback_ndx;
/* Buffer attached with output layer. Device uses it for commit call */
struct mdp_layer_buffer buffer;
/* 32bits reserved value for future usage. */
uint32_t reserved[6];
};
/*
* Commit structure holds layer stack send by client for validate and commit
* call. If layers are different between validate and commit call then commit
* call will also do validation. In such case, commit may fail.
*/
struct mdp_layer_commit_v1 {
/*
* Flag to enable/disable properties for commit/validate call. Refer
* validate/commit flag config section for all possible flags.
*/
uint32_t flags;
/*
* This is an output parameter.
*
* Frame buffer device provides release fence handle to client. It
* triggers release fence when display hardware has consumed all the
* buffers attached to this commit call and buffer is ready for reuse
* for primary and external. For writeback case, it triggers it when
* output buffer is ready for consumer.
*/
int release_fence;
/*
* Left_roi is optional configuration. Client configures it only when
* partial update is enabled. It defines the "region of interest" on
* left part of panel when it is split display. For non-split display,
* it defines the "region of interest" on the panel.
*/
struct mdp_rect left_roi;
/*
* Right_roi is optional configuration. Client configures it only when
* partial update is enabled. It defines the "region of interest" on
* right part of panel for split display configuration. It is not
* required for non-split display.
*/
struct mdp_rect right_roi;
/* Pointer to a list of input layers for composition. */
struct mdp_input_layer __user *input_layers;
/* Input layer count present in input list */
uint32_t input_layer_cnt;
/*
* Output layer for writeback display. It supports only one
* layer as output layer. This is not required for primary
* and external displays
*/
struct mdp_output_layer __user *output_layer;
/*
* This is an output parameter.
*
* Frame buffer device provides retire fence handle if
* COMMIT_RETIRE_FENCE flag is set in commit call. It triggers
* retire fence when current layers are swapped with new layers
* on display hardware. For video mode panel and writeback,
* retire fence and release fences are triggered at the same
* time while command mode panel triggers release fence first
* (on pingpong done) and retire fence (on rdptr done)
* after that.
*/
int retire_fence;
/* 32-bits reserved value for future usage. */
uint32_t reserved[6];
};
/*
* mdp_overlay_list - argument for ioctl MSMFB_ATOMIC_COMMIT
*/
struct mdp_layer_commit {
/*
* 32bit version indicates the commit structure selection
* from union. Lower 16bits indicates the minor version while
* higher 16bits indicates the major version. It selects the
* commit structure based on major version selection. Minor version
* indicates that reserved fields are in use.
*
* Current supported version is 1.0 (Major:1 Minor:0)
*/
uint32_t version;
union {
/* Layer commit/validate definition for V1 */
struct mdp_layer_commit_v1 commit_v1;
};
};
struct mdp_point {
uint32_t x;
uint32_t y;
};
/*
* Async updatable layers. One layer holds configuration for one pipe.
*/
struct mdp_async_layer {
/*
* Flag to enable/disable properties for layer configuration. Refer
* layer flag config section for all possible flags.
*/
uint32_t flags;
/*
* Pipe selection for this layer by client. Client provides the
* pipe index that the device reserved during ATOMIC_COMMIT.
*/
uint32_t pipe_ndx;
/* Source start x,y. */
struct mdp_point src;
/* Destination start x,y. */
struct mdp_point dst;
/*
* This is an output parameter.
*
* Frame buffer device sets error code based on the failure.
*/
int error_code;
uint32_t reserved[3];
};
/*
* mdp_position_update - argument for ioctl MSMFB_ASYNC_POSITION_UPDATE
*/
struct mdp_position_update {
/* Pointer to a list of async updatable input layers */
struct mdp_async_layer __user *input_layers;
/* Input layer count present in input list */
uint32_t input_layer_cnt;
};
#endif