| #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 |