You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
hardware_samsung/exynos4/hal/include/sec_g2d_4x.h

339 lines
7.7 KiB

/*
* Copyright 2011, Samsung Electronics Co. LTD
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef _SEC_G2D_DRIVER_H_
#define _SEC_G2D_DRIVER_H_
#define SEC_G2D_DEV_NAME "/dev/fimg2d"
#define G2D_ALPHA_VALUE_MAX (255)
/* ioctl commands */
#define FIMG2D_IOCTL_MAGIC 'F'
#define FIMG2D_BITBLT_BLIT _IOWR(FIMG2D_IOCTL_MAGIC, 0, \
struct fimg2d_blit)
#define FIMG2D_BITBLT_SYNC _IOW(FIMG2D_IOCTL_MAGIC, 1, int)
#define FIMG2D_BITBLT_VERSION _IOR(FIMG2D_IOCTL_MAGIC, 2, \
struct fimg2d_version)
/**
* @BLIT_SYNC: sync mode, to wait for blit done irq
* @BLIT_ASYNC: async mode, not to wait for blit done irq
*
*/
enum blit_sync {
BLIT_SYNC,
BLIT_ASYNC,
};
/**
* @ADDR_PHYS: physical address
* @ADDR_USER: user virtual address (physically Non-contiguous)
* @ADDR_USER_RSVD: user virtual address (physically Contiguous)
* @ADDR_DEVICE: specific device virtual address
*/
enum addr_space {
ADDR_NONE,
ADDR_PHYS,
ADDR_KERN,
ADDR_USER,
ADDR_USER_RSVD,
ADDR_DEVICE,
};
/**
* Pixel order complies with little-endian style
*
* DO NOT CHANGE THIS ORDER
*/
enum pixel_order {
AX_RGB = 0,
RGB_AX,
AX_BGR,
BGR_AX,
ARGB_ORDER_END,
P1_CRY1CBY0,
P1_CBY1CRY0,
P1_Y1CRY0CB,
P1_Y1CBY0CR,
P1_ORDER_END,
P2_CRCB,
P2_CBCR,
P2_ORDER_END,
};
/**
* DO NOT CHANGE THIS ORDER
*/
enum color_format {
CF_XRGB_8888 = 0,
CF_ARGB_8888,
CF_RGB_565,
CF_XRGB_1555,
CF_ARGB_1555,
CF_XRGB_4444,
CF_ARGB_4444,
CF_RGB_888,
CF_YCBCR_444,
CF_YCBCR_422,
CF_YCBCR_420,
CF_A8,
CF_L8,
SRC_DST_FORMAT_END,
CF_MSK_1BIT,
CF_MSK_4BIT,
CF_MSK_8BIT,
CF_MSK_16BIT_565,
CF_MSK_16BIT_1555,
CF_MSK_16BIT_4444,
CF_MSK_32BIT_8888,
MSK_FORMAT_END,
};
enum rotation {
ORIGIN,
ROT_90, /* clockwise */
ROT_180,
ROT_270,
XFLIP, /* x-axis flip */
YFLIP, /* y-axis flip */
};
/**
* @NO_REPEAT: no effect
* @REPEAT_NORMAL: repeat horizontally and vertically
* @REPEAT_PAD: pad with pad color
* @REPEAT_REFLECT: reflect horizontally and vertically
* @REPEAT_CLAMP: pad with edge color of original image
*
* DO NOT CHANGE THIS ORDER
*/
enum repeat {
NO_REPEAT = 0,
REPEAT_NORMAL, /* default setting */
REPEAT_PAD,
REPEAT_REFLECT, REPEAT_MIRROR = REPEAT_REFLECT,
REPEAT_CLAMP,
};
enum scaling {
NO_SCALING,
SCALING_NEAREST,
SCALING_BILINEAR,
};
/**
* @SCALING_PIXELS: ratio in pixels
* @SCALING_RATIO: ratio in fixed point 16
*/
enum scaling_factor {
SCALING_PIXELS,
SCALING_RATIO,
};
/**
* premultiplied alpha
*/
enum premultiplied {
PREMULTIPLIED,
NON_PREMULTIPLIED,
};
/**
* @TRANSP: discard bluescreen color
* @BLUSCR: replace bluescreen color with background color
*/
enum bluescreen {
OPAQUE,
TRANSP,
BLUSCR,
};
/**
* DO NOT CHANGE THIS ORDER
*/
enum blit_op {
BLIT_OP_SOLID_FILL = 0,
BLIT_OP_CLR,
BLIT_OP_SRC, BLIT_OP_SRC_COPY = BLIT_OP_SRC,
BLIT_OP_DST,
BLIT_OP_SRC_OVER,
BLIT_OP_DST_OVER, BLIT_OP_OVER_REV = BLIT_OP_DST_OVER,
BLIT_OP_SRC_IN,
BLIT_OP_DST_IN, BLIT_OP_IN_REV = BLIT_OP_DST_IN,
BLIT_OP_SRC_OUT,
BLIT_OP_DST_OUT, BLIT_OP_OUT_REV = BLIT_OP_DST_OUT,
BLIT_OP_SRC_ATOP,
BLIT_OP_DST_ATOP, BLIT_OP_ATOP_REV = BLIT_OP_DST_ATOP,
BLIT_OP_XOR,
BLIT_OP_ADD,
BLIT_OP_MULTIPLY,
BLIT_OP_SCREEN,
BLIT_OP_DARKEN,
BLIT_OP_LIGHTEN,
BLIT_OP_DISJ_SRC_OVER,
BLIT_OP_DISJ_DST_OVER, BLIT_OP_SATURATE = BLIT_OP_DISJ_DST_OVER,
BLIT_OP_DISJ_SRC_IN,
BLIT_OP_DISJ_DST_IN, BLIT_OP_DISJ_IN_REV = BLIT_OP_DISJ_DST_IN,
BLIT_OP_DISJ_SRC_OUT,
BLIT_OP_DISJ_DST_OUT, BLIT_OP_DISJ_OUT_REV = BLIT_OP_DISJ_DST_OUT,
BLIT_OP_DISJ_SRC_ATOP,
BLIT_OP_DISJ_DST_ATOP, BLIT_OP_DISJ_ATOP_REV = BLIT_OP_DISJ_DST_ATOP,
BLIT_OP_DISJ_XOR,
BLIT_OP_CONJ_SRC_OVER,
BLIT_OP_CONJ_DST_OVER, BLIT_OP_CONJ_OVER_REV = BLIT_OP_CONJ_DST_OVER,
BLIT_OP_CONJ_SRC_IN,
BLIT_OP_CONJ_DST_IN, BLIT_OP_CONJ_IN_REV = BLIT_OP_CONJ_DST_IN,
BLIT_OP_CONJ_SRC_OUT,
BLIT_OP_CONJ_DST_OUT, BLIT_OP_CONJ_OUT_REV = BLIT_OP_CONJ_DST_OUT,
BLIT_OP_CONJ_SRC_ATOP,
BLIT_OP_CONJ_DST_ATOP, BLIT_OP_CONJ_ATOP_REV = BLIT_OP_CONJ_DST_ATOP,
BLIT_OP_CONJ_XOR,
/* user select coefficient manually */
BLIT_OP_USER_COEFF,
BLIT_OP_USER_SRC_GA,
/* Add new operation type here */
/* end of blit operation */
BLIT_OP_END,
/* driver not supporting format */
BLIT_OP_NOT_SUPPORTED
};
/**
* @start: start address or unique id of image
*/
struct fimg2d_addr {
enum addr_space type;
unsigned long start;
};
struct fimg2d_rect {
int x1;
int y1;
int x2; /* x1 + width */
int y2; /* y1 + height */
};
/**
* pixels can be different from src, dst or clip rect
*/
struct fimg2d_scale {
enum scaling mode;
/* ratio in pixels */
int src_w, src_h;
int dst_w, dst_h;
};
struct fimg2d_clip {
bool enable;
int x1;
int y1;
int x2; /* x1 + width */
int y2; /* y1 + height */
};
struct fimg2d_repeat {
enum repeat mode;
unsigned long pad_color;
};
/**
* @bg_color: bg_color is valid only if bluescreen mode is BLUSCR.
*/
struct fimg2d_bluscr {
enum bluescreen mode;
unsigned long bs_color;
unsigned long bg_color;
};
/**
* @plane2: address info for CbCr in YCbCr 2plane mode
* @rect: crop/clip rect
* @need_cacheopr: true if cache coherency is required
*/
struct fimg2d_image {
int width;
int height;
int stride;
enum pixel_order order;
enum color_format fmt;
struct fimg2d_addr addr;
struct fimg2d_addr plane2;
struct fimg2d_rect rect;
bool need_cacheopr;
};
/**
* @solid_color:
* src color instead of src image / dst color instead of dst read image.
* color format and order must be ARGB8888(A is MSB).
* premultiplied format must be same to 'premult' of this struct.
* @g_alpha: global(constant) alpha. 0xff is opaque, 0 is transparnet
* @dither: dithering
* @rotate: rotation degree in clockwise
* @premult: alpha premultiplied mode for read & write
* @scaling: common scaling info for src and mask image.
* @repeat: repeat type (tile mode)
* @bluscr: blue screen and transparent mode
*/
struct fimg2d_param {
unsigned long solid_color;
unsigned char g_alpha;
bool dither;
enum rotation rotate;
enum premultiplied premult;
struct fimg2d_scale scaling;
struct fimg2d_repeat repeat;
struct fimg2d_bluscr bluscr;
struct fimg2d_clip clipping;
};
/**
* @op: blit operation mode
* @src: set when using src image
* @msk: set when using mask image
* @tmp: set when using 2-step blit at a single command
* @dst: dst must not be null
* * tmp image must be the same to dst except memory address
* @seq_no: user debugging info.
* for example, user can set sequence number or pid.
*/
struct fimg2d_blit {
enum blit_op op;
struct fimg2d_param param;
struct fimg2d_image *src;
struct fimg2d_image *msk;
struct fimg2d_image *tmp;
struct fimg2d_image *dst;
enum blit_sync sync;
unsigned int seq_no;
};
#endif /*_SEC_G2D_DRIVER_H_*/