xref: /utopia/UTPA2-700.0.x/modules/graphic/utopia_adaption/gop/GOP_adp.c (revision 53ee8cc121a030b8d368113ac3e966b4705770ef)

#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <asm/uaccess.h>

#include "GOP_adp.h"
#include "utopia.h"
#include "utopia_adp.h"
#include "drvGOP.h"
#include "apiGOP.h"
#include "apiGOP_v2.h"
#include "apiGOP_priv.h"
#include <linux/compat.h>

extern spt_MS_NULL;

//MAPI_CMD_GOP_INIT:
#ifdef BIFROST_32BIT_MODE
UADP_SPT_NAMEnNXT_DEF(GOP_INIT_pInfo,2);
UADP_SPT_NAMEnNXT_DEF(GOP_INIT,1);
#else
UADP_SPT_NAMEnNXT_DEF(GOP_INIT_pInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_INIT,1);
#endif
//MAPI_CMD_GOP_GET_CHIPCAPS:
UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_WORD_UNIT_WordUnit,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_WORD_UNIT,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_GWIN_NUM_TotalGwinNum,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_GWIN_NUM,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_VERSION_LibVer,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_VERSION,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_CONSALPHA_VALIDBITS_ConsAlpha_bits,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_CONSALPHA_VALIDBITS,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_PALETTE_Pal,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_PALETTE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_DWIN_DwinCap,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_DWIN,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_GOP_MUX_MuxCap,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_GOP_MUX,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_PIXELMODE_SUPPORT_Support,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_PIXELMODE_SUPPORT,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_STRETCH_A0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_STRETCH,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_SUPPORT_AFBC_A0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GETCAPS_SUPPORT_AFBC,1);

//MAPI_CMD_GOP_SET_CONFIG:
//MAPI_CMD_GOP_GET_CONFIG:
UADP_SPT_NAMEnNXT_DEF(GOP_CONFIG_IGNOREINIT_IgnoreInit,0);
UADP_SPT_NAMEnNXT_DEF(GOP_CONFIG_IGNOREINIT,1);

UADP_SPT_NAMEnNXT_DEF(GOP_CONFIG_CONSALPHA_BITS_AlphaBits,0);
UADP_SPT_NAMEnNXT_DEF(GOP_CONFIG_CONSALPHA_BITS,1);

UADP_SPT_NAMEnNXT_DEF(GOP_CONFIG_TIMING_INFO_A0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_CONFIG_TIMING_INFO,1);

UADP_SPT_NAMEnNXT_DEF(GOP_CONFIG_IS_PIXEL_ENABLE_A0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_CONFIG_IS_PIXEL_ENABLE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_CONFIG_GET_MAXFBNUM_A0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_CONFIG_GET_MAXFBNUM,1);

//MAPI_CMD_GOP_SET_PROPERTY:
//MAPI_CMD_GOP_GET_PROPERTY:
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_MIUSEL_miusel,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_MIUSEL,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_CONTRAST_RGB,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_CONTRAST,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_BRIGHTNESS_Bri,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_BRIGHTNESS,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_OUTPUT_COLOR_output,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_OUTPUT_COLOR,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_UV_SWAP_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_UV_SWAP,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_YC_SWAP_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_YC_SWAP,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_HSTART_PanelHStr,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_HSTART,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_TRANSCOLOR_trans_clr,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_TRANSCOLOR,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_PROGRESSIVE_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_PROGRESSIVE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_ALPHAINVERSE_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_ALPHAINVERSE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_PREALPHAMODE_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_PREALPHAMODE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_FIELD_INVERSE_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_FIELD_INVERSE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_HSCALE_RATIO_Hscale,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_HSCALE_RATIO,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_VSCALE_RATIO_Vscale,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_VSCALE_RATIO,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_OUTPUT_TIMING_stInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_OUTPUT_TIMING,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_PIXELBASE_ENABLE_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_PIXELBASE_ENABLE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_CLK_DstType,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_CLK,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_FORCE_WRITE_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_FORCE_WRITE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_BANK_FORCE_WRITE_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_BANK_FORCE_WRITE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_3D_LR_EXCHANGE_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_3D_LR_EXCHANGE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_VE_OSD_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_VE_OSD,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_OUTPUT_LAYER_SWITCH_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_OUTPUT_LAYER_SWITCH,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_SWAP_OVERLAP_WIN_win,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_SWAP_OVERLAP_WIN,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_BW_STRENGTH_eGOPBWStr,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_BW_STRENGTH,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_LB_COUPLE_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_LB_COUPLE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_YUV_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_YUV,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_REG_UPDATED_Updated,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_REG_UPDATED,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_RELATIVE_WIN_PRIO_GwinPri,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_RELATIVE_WIN_PRIO,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_RESOURCE_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_RESOURCE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_MAXFBNUM_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_MAXFBNUM,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_MULTI_ALPHA_ENABLE_A0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_MULTI_ALPHA_ENABLE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_AFBC_CORE_RESET_A0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_AFBC_CORE_RESET,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_AFBC_CORE_EN_A0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_AFBC_CORE_EN,1);

UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_TLB_ENABLE_A0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PROPERTY_TLB_ENABLE,1);

#ifdef BIFROST_32BIT_MODE
UADP_SPT_NAMEnNXT_DEF(GOP_INIT_pInfo_noparameter_init,2);
UADP_SPT_NAMEnNXT_DEF(GOP_INIT_pInfo_noparameter,1);
#else
UADP_SPT_NAMEnNXT_DEF(GOP_INIT_pInfo_noparameter_init,0);
UADP_SPT_NAMEnNXT_DEF(GOP_INIT_pInfo_noparameter,1);
#endif

//MAPI_CMD_GOP_SET_DST:
UADP_SPT_NAMEnNXT_DEF(GOP_SETDST_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_SETDST,1);
//MAPI_CMD_GOP_GET_DST:
UADP_SPT_NAMEnNXT_DEF(GOP_GETDST_dst,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GETDST,1);
//MAPI_CMD_GOP_SET_MUX:
UADP_SPT_NAMEnNXT_DEF(GOP_SETMUX_MuxInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_SETMUX,1);
//MAPI_CMD_GOP_SET_LAYER:
//MAPI_CMD_GOP_GET_LAYER:
UADP_SPT_NAMEnNXT_DEF(GOP_LAYER_LayerInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_LAYER,1);
//MAPI_CMD_GOP_SET_MIRROR:
UADP_SPT_NAMEnNXT_DEF(GOP_MIRROR,0);
//MAPI_CMD_GOP_GET_MIRROR:
UADP_SPT_NAMEnNXT_DEF(GOP_GETMIRROR_PARAM_A0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GETMIRROR_PARAM,1);
//MAPI_CMD_GOP_GET_STATUS:
UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_INIT_Init,0);
UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_INIT,1);

UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_GOP_MAXNUM_MaxGopNum,0);
UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_GOP_MAXNUM,1);

UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_GWIN_MAXNUM_GOP_GWIN_NUM,0);
UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_GWIN_MAXNUM,1);

UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_GWIN_TOTALNUM_GwinNum,0);
UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_GWIN_TOTALNUM,1);

UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_VERSION_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_VERSION,1);

UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_MUX_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_MUX,1);

UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_CURRENT_GOP_CurrentGop,0);
UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_CURRENT_GOP,1);

UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_CURRENT_GWIN_CurrentGwin,0);
UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_CURRENT_GWIN,1);

UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_CURRENT_FBID_CurrentFbid,0);
UADP_SPT_NAMEnNXT_DEF(GOP_STATUS_CURRENT_FBID,1);
//MAPI_CMD_GOP_GWIN_SET_STRETCH:
//MAPI_CMD_GOP_GWIN_GET_STRETCH:
UADP_SPT_NAMEnNXT_DEF(GOP_STRETCH_Stretch,0);
UADP_SPT_NAMEnNXT_DEF(GOP_STRETCH,1);
//MAPI_CMD_GOP_GWIN_SET_PROPERTY:
//MAPI_CMD_GOP_GWIN_GET_PROPERTY:
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_BLENDING_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_BLENDING,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_NEWAPLHA_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_NEWAPLHA,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_ENABLE_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_ENABLE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_BLINK_Rate,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_BLINK,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_SHARE_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_SHARE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_SHARE_CNT_SharedCnt,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_SHARE_CNT,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_SWITCH_2_GWIN_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_SWITCH_2_GWIN,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_3D_MODE_3DMode,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_3D_MODE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_EXIST_Exist,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_EXIST,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_FREE_ID_FreeId,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_FREE_ID,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_GET_FB_FbId,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_GET_FB,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_GET_GOP_GOP,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_GET_GOP,1);

UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_GOPTILE_A0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_PROPERTY_GOPTILE,1);

//MAPI_CMD_GOP_GWIN_MAPFB2WIN:
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_MAPFBINFO_Set,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_MAPFBINFO,1);
//MAPI_CMD_GOP_GWIN_SET_WININFO:
//MAPI_CMD_GOP_GWIN_GET_WININFO:
#ifdef BIFROST_32BIT_MODE
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_SETWININFO_info,1);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_SETWININFO,1);
#else
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_SETWININFO_info,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_SETWININFO,1);
#endif
//MAPI_CMD_GOP_GWIN_SETDISPLAY:
#ifdef BIFROST_32BIT_MODE
UADP_SPT_NAMEnNXT_DEF(GOP_GwinInfo_A0,1);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_DISPLAY_DisplayInfo,1);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_DISPLAY,1);
#else
UADP_SPT_NAMEnNXT_DEF(GOP_GwinInfo_A0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_DISPLAY_DisplayInfo,1);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_DISPLAY,1);
#endif
//MAPI_CMD_GOP_GWIN_DESTROY:
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_DESTROY_ptr,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_DESTROY,1);
//MAPI_CMD_GOP_GFLIP_CLEARQUEUE:
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_CLEARQUEUE_ClearInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_CLEARQUEUE,1);
//MAPI_CMD_GOP_GFLIP_SWITCHGWIN:
#ifdef BIFROST_32BIT_MODE
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_GFLIP_SWITCH_GWIN_FlipInfo_pQueueCnt,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_GFLIP_SWITCH_GWIN_FlipInfo,3);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_GFLIP_SWITCH_GWIN,1);
#else
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_GFLIP_SWITCH_GWIN_FlipInfo_pQueueCnt,0);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_GFLIP_SWITCH_GWIN_FlipInfo,1);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_GFLIP_SWITCH_GWIN,1);
#endif
//MAPI_CMD_GOP_GFLIP_SWITCHMULTIGWIN:
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_GFLIP_SWITCH_MULTI_Info,3);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_GFLIP_SWITCH_MULTI_GWIN_MultiFlipInfo,1);
UADP_SPT_NAMEnNXT_DEF(GOP_GWIN_GFLIP_SWITCH_MULTI_GWIN,1);
//MAPI_CMD_GOP_GFLIP_RESTORE_VSYNC_LMT:

//MAPI_CMD_GOP_SET_PINPON:
UADP_SPT_NAMEnNXT_DEF(GOP_SET_PINPON_PINPON_PINPONInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_SET_PINPON_PINPON,1);

//MAPI_CMD_GOP_FB_CREATE:
#ifdef BIFROST_32BIT_MODE
UADP_SPT_NAMEnNXT_DEF(GOP_CREATE_BUFFER_BufInfo,1);
UADP_SPT_NAMEnNXT_DEF(GOP_CREATE_BUFFER,1);
#else
UADP_SPT_NAMEnNXT_DEF(GOP_CREATE_BUFFER_BufInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_CREATE_BUFFER,1);
#endif
//MAPI_CMD_GOP_FB_DESTROY:
UADP_SPT_NAMEnNXT_DEF(GOP_DELETE_BUFFER_BufId,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DELETE_BUFFER,1);
//MAPI_CMD_GOP_FB_GETINFO:
//MAPI_CMD_GOP_FB_SETINFO:
#ifdef BIFROST_32BIT_MODE
UADP_SPT_NAMEnNXT_DEF(GOP_FB_INFO_BufInfo,1);
UADP_SPT_NAMEnNXT_DEF(GOP_FB_INFO,1);
#else
UADP_SPT_NAMEnNXT_DEF(GOP_FB_INFO_BufInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_FB_INFO,1);
#endif
//MAPI_CMD_GOP_FB_SET_PROPERTY:
//MAPI_CMD_GOP_FB_GET_PROPERTY:
UADP_SPT_NAMEnNXT_DEF(GOP_FB_PROPERTY_POOLID_Pool,0);
UADP_SPT_NAMEnNXT_DEF(GOP_FB_PROPERTY_POOLID,1);

UADP_SPT_NAMEnNXT_DEF(GOP_FB_PROPERTY_EXIST_Exist,0);
UADP_SPT_NAMEnNXT_DEF(GOP_FB_PROPERTY_EXIST,1);

UADP_SPT_NAMEnNXT_DEF(GOP_FB_PROPERTY_OBTAIN_1,0);
UADP_SPT_NAMEnNXT_DEF(GOP_FB_PROPERTY_OBTAIN,1);

//MAPI_CMD_GOP_PALETTE_SET_CONFIG:
UADP_SPT_NAMEnNXT_DEF(GOP_PALETTE_CONFIG_PaletteInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PALETTE_CONFIG,1);
//MAPI_CMD_GOP_PALETTE_SET_ENTRY:
//MAPI_CMD_GOP_PALETTE_GET_ENTRY:
UADP_SPT_NAMEnNXT_DEF(GOP_PALETTE_SET_ENTRY_A0B0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_PALETTE_SET_ENTRY_A0,1);
UADP_SPT_NAMEnNXT_DEF(GOP_PALETTE_SET_ENTRY,1);

//MAPI_CMD_GOP_SET_SCROLL:
UADP_SPT_NAMEnNXT_DEF(GOP_SCROLL_CONFIG_ScrollInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_SCROLL_CONFIG,1);

UADP_SPT_NAMEnNXT_DEF(GOP_SCROLL_RATE_rate,0);
UADP_SPT_NAMEnNXT_DEF(GOP_SCROLL_RATE,1);
//MAPI_CMD_GOP_GWIN_SET_FADE:
UADP_SPT_NAMEnNXT_DEF(GOP_SET_FADE_CONFIG_FadeInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_SET_FADE_CONFIG,1);
//MAPI_CMD_GOP_DWIN_INIT:

//MAPI_CMD_GOP_DWIN_CAPTURE:
#ifdef BIFROST_32BIT_MODE
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_CAPTURE_Dwin,4);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_CAPTURE,1);
#else
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_CAPTURE_Dwin,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_CAPTURE,1);
#endif
//MAPI_CMD_GOP_DWIN_INTR:
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_INTR_STATUS_CONTROL_IntrCtrl,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_INTR_STATUS_CONTROL,1);

UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_INTR_STATUS_GETINFO_Intr,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_INTR_STATUS_GETINFO,1);

UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_INTR_STATUS_GETINFO_TIMEOUT_Timeout,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_INTR_STATUS_GETINFO_TIMEOUT,1);
//MAPI_CMD_GOP_DWIN_SET_PROPERTY:
//MAPI_CMD_GOP_DWIN_GET_PROPERTY:
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_R2Y_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_R2Y,1);

UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_UV_SWAP_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_UV_SWAP,1);

UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_UV_SAMPLE_enMode,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_UV_SAMPLE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_SOURCE_SCAN_TYPE_enMode,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_SOURCE_SCAN_TYPE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_ALPHA_VALUE_Value,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_ALPHA_VALUE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_ALPHA_SOURCE_enSource,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_ALPHA_SOURCE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_ALPHA_INVERSE_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_ALPHA_INVERSE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_SKIP_FRAME_Count,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_SKIP_FRAME,1);
#ifdef BIFROST_32BIT_MODE
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_PINPON_Pinpon,2);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_PINPON,1);
#else
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_PINPON_Pinpon,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_PINPON,1);
#endif
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_INTERRUP_INFO_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_INTERRUP_INFO,1);

UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_CAPTURE_INFO_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_DWIN_PROPERTY_CAPTURE_INFO,1);
//MAPI_CMD_GOP_MIXER_SET_PROPERTY:
//MAPI_CMD_GOP_MIXER_GET_PROPERTY:
UADP_SPT_NAMEnNXT_DEF(GOP_MIXER_PROPERTY_OUTPUT_TIMING_MTInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MIXER_PROPERTY_OUTPUT_TIMING,1);

UADP_SPT_NAMEnNXT_DEF(GOP_MIXER_PROPERTY_TO_OP_OUTPUT_TIMING_MT,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MIXER_PROPERTY_TO_OP_OUTPUT_TIMING,1);

UADP_SPT_NAMEnNXT_DEF(GOP_MIXER_PROPERTY_V_FILTER_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MIXER_PROPERTY_V_FILTER,1);

UADP_SPT_NAMEnNXT_DEF(GOP_MIXER_PROPERTY_OLD_BLENDING_MODE_MOBM,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MIXER_PROPERTY_OLD_BLENDING_MODE,1);
//MAPI_CMD_GOP_VE_SET_PROPERTY:
UADP_SPT_NAMEnNXT_DEF(GOP_VE_PROPERTY_OUTPUT_TIMING_VEInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_VE_PROPERTY_OUTPUT_TIMING,1);
//MAPI_CMD_GOP_UPDATE:
UADP_SPT_NAMEnNXT_DEF(GOP_UPDATE_UpdateInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_UPDATE,1);
//MAPI_CMD_GOP_REGISTER_CB:
UADP_SPT_NAMEnNXT_DEF(GOP_CB_INTERLACE_A0, 0);
UADP_SPT_NAMEnNXT_DEF(GOP_CB_INTERLACE,1);

UADP_SPT_NAMEnNXT_DEF(GOP_CB_HSTART_A0, 0);
UADP_SPT_NAMEnNXT_DEF(GOP_CB_HSTART,1);
//MAPI_CMD_GOP_TESTPATTERN:
UADP_SPT_NAMEnNXT_DEF(GOP_TESTPATTERN, 0);
//MAPI_CMD_GOP_SELECTION:
UADP_SPT_NAMEnNXT_DEF(GOP_SELECTION_SELGOP_A0, 0);
UADP_SPT_NAMEnNXT_DEF(GOP_SELECTION_SELGOP,1);

UADP_SPT_NAMEnNXT_DEF(GOP_SELECTION_SELGWIN_A0, 0);
UADP_SPT_NAMEnNXT_DEF(GOP_SELECTION_SELGWIN,1);

#ifdef BIFROST_32BIT_MODE
UADP_SPT_NAMEnNXT_DEF(GOP_SELECTION_SELFB_A0, 1);
UADP_SPT_NAMEnNXT_DEF(GOP_SELECTION_SELFB,1);
#else
UADP_SPT_NAMEnNXT_DEF(GOP_SELECTION_SELFB_A0, 0);
UADP_SPT_NAMEnNXT_DEF(GOP_SELECTION_SELFB,1);
#endif
//MAPI_CMD_GOP_MUTEX:
UADP_SPT_NAMEnNXT_DEF(GOP_MUTEX_pSet,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MUTEX,1);
//MAPI_CMD_GOP_MISC:
UADP_SPT_NAMEnNXT_DEF(GOP_MISC_ENABLE_T3D_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MISC_ENABLE_T3D,1);

UADP_SPT_NAMEnNXT_DEF(GOP_MISC_SET_CAPTURE_CLK_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MISC_SET_CAPTURE_CLK,1);

UADP_SPT_NAMEnNXT_DEF(GOP_MISC_POWER_OFF_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MISC_POWER_OFF,1);

UADP_SPT_NAMEnNXT_DEF(GOP_MISC_POWER_ON_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MISC_POWER_ON,1);

UADP_SPT_NAMEnNXT_DEF(GOP_MISC_GET_RT_STATUS_GopApiSts,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MISC_GET_RT_STATUS,1);

UADP_SPT_NAMEnNXT_DEF(GOP_MISC_GET_INFO_GopApiInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MISC_GET_INFO,1);

UADP_SPT_NAMEnNXT_DEF(GOP_MISC_AT_EXIT_u32,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MISC_AT_EXIT,1);

UADP_SPT_NAMEnNXT_DEF(GOP_MISC_OC_FB_INFO_OCFbInfo,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MISC_OC_FB_INFO,1);

UADP_SPT_NAMEnNXT_DEF(GOP_MISC_TESTPATTERN_ALPHA_bEn,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MISC_TESTPATTERN_ALPHA,1);

UADP_SPT_NAMEnNXT_DEF(GOP_MISC_DELETE_GWINSIZE_A0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_MISC_DELETE_GWINSIZE,1);

//MAPI_CMD_GOP_RESETPOOL:

UADP_SPT_NAMEnNXT_DEF(GOP_POWERSTATE_PARAM_A0,0);
UADP_SPT_NAMEnNXT_DEF(GOP_POWERSTATE_PARAM,1);

#ifdef CONFIG_COMPAT
typedef struct GOP_PALETTE_SET_PARAM_32
{
    compat_uint_t   type;
    compat_uptr_t   pClut;
    compat_uint_t   u32Size;
}GOP_PALETTE_SET_PARAM_32;


typedef struct GOP_PALETTE_ENTRY_32
{
    compat_uint_t   gop_idx;
    compat_uint_t   start;
    compat_uint_t   end;
    compat_uptr_t   pClut;
    compat_uint_t   palType;
    compat_uint_t   palSrc;
}GOP_PALETTE_ENTRY_32;
#endif


MS_U32 GOP_adp_Init(FUtopiaIOctl* pIoctl)
{
    //MAPI_CMD_GOP_INIT
#ifdef BIFROST_32BIT_MODE
    UADP_SDT_NAME2(GOP_INIT_pInfo,GOP_InitInfo,UADP_SDT_AT,u32GOPRBAdr,MS_NULL,UADP_SDT_AT,u32GOPRegdmaAdr,MS_NULL);
#else
    UADP_SDT_NAME0(GOP_INIT_pInfo,GOP_InitInfo);
#endif
    UADP_SPT_NAME1NXT(GOP_INIT,GOP_INIT_PARAM,pInfo,GOP_INIT_pInfo);
    //MAPI_CMD_GOP_GET_CHIPCAPS:
    UADP_SPT_NAME0NXT(GOP_GETCAPS_WORD_UNIT_WordUnit,MS_U16);
    UADP_SPT_NAME1NXT(GOP_GETCAPS_WORD_UNIT,GOP_GETCAPS_PARAM,pInfo,GOP_GETCAPS_WORD_UNIT_WordUnit);

    UADP_SPT_NAME0NXT(GOP_GETCAPS_GWIN_NUM_TotalGwinNum,MS_U16);
    UADP_SPT_NAME1NXT(GOP_GETCAPS_GWIN_NUM,GOP_GETCAPS_PARAM,pInfo,GOP_GETCAPS_GWIN_NUM_TotalGwinNum);

    UADP_SPT_NAME0NXT(GOP_GETCAPS_VERSION_LibVer,GOP_LIB_VER);
    UADP_SPT_NAME1NXT(GOP_GETCAPS_VERSION,GOP_GETCAPS_PARAM,pInfo,GOP_GETCAPS_VERSION_LibVer);

    UADP_SPT_NAME0NXT(GOP_GETCAPS_CONSALPHA_VALIDBITS_ConsAlpha_bits,DRV_GOP_CONSALPHA_BITS);
    UADP_SPT_NAME1NXT(GOP_GETCAPS_CONSALPHA_VALIDBITS,GOP_GETCAPS_PARAM,pInfo,GOP_GETCAPS_CONSALPHA_VALIDBITS_ConsAlpha_bits);

    UADP_SPT_NAME0NXT(GOP_GETCAPS_PALETTE_Pal,GOP_CAP_PAL_TYPE);
    UADP_SPT_NAME1NXT(GOP_GETCAPS_PALETTE,GOP_GETCAPS_PARAM,pInfo,GOP_GETCAPS_PALETTE_Pal);

    UADP_SPT_NAME0NXT(GOP_GETCAPS_DWIN_DwinCap,GOP_DWIN_CAP);
    UADP_SPT_NAME1NXT(GOP_GETCAPS_DWIN,GOP_GETCAPS_PARAM,pInfo,GOP_GETCAPS_DWIN_DwinCap);

    UADP_SPT_NAME0NXT(GOP_GETCAPS_GOP_MUX_MuxCap,ST_DRV_GOP_MUX_CAP_EX);
    UADP_SPT_NAME1NXT(GOP_GETCAPS_GOP_MUX,GOP_GETCAPS_PARAM,pInfo,GOP_GETCAPS_GOP_MUX_MuxCap);

    UADP_SPT_NAME0NXT(GOP_GETCAPS_PIXELMODE_SUPPORT_Support,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_GETCAPS_PIXELMODE_SUPPORT,GOP_GETCAPS_PARAM,pInfo,GOP_GETCAPS_PIXELMODE_SUPPORT_Support);

    UADP_SPT_NAME0NXT(GOP_GETCAPS_STRETCH_A0,GOP_CAP_STRETCH_INFO);
    UADP_SPT_NAME1NXT(GOP_GETCAPS_STRETCH,GOP_GETCAPS_PARAM,pInfo,GOP_GETCAPS_STRETCH_A0);

    UADP_SPT_NAME0NXT(GOP_GETCAPS_SUPPORT_AFBC_A0,GOP_CAP_AFBC_INFO);
    UADP_SPT_NAME1NXT(GOP_GETCAPS_SUPPORT_AFBC,GOP_GETCAPS_PARAM,pInfo,GOP_GETCAPS_SUPPORT_AFBC_A0);

    //MAPI_CMD_GOP_SET_CONFIG:
    //MAPI_CMD_GOP_GET_CONFIG:
    UADP_SPT_NAME0NXT(GOP_CONFIG_IGNOREINIT_IgnoreInit,EN_GOP_IGNOREINIT);
    UADP_SPT_NAME1NXT(GOP_CONFIG_IGNOREINIT,GOP_SETCONFIG_PARAM,pCfg,GOP_CONFIG_IGNOREINIT_IgnoreInit);

    UADP_SPT_NAME0NXT(GOP_CONFIG_CONSALPHA_BITS_AlphaBits,DRV_GOP_CONSALPHA_BITS);
    UADP_SPT_NAME1NXT(GOP_CONFIG_CONSALPHA_BITS,GOP_SETCONFIG_PARAM,pCfg,GOP_CONFIG_CONSALPHA_BITS_AlphaBits);

    UADP_SPT_NAME0NXT(GOP_CONFIG_TIMING_INFO_A0,ST_GOP_TIMING_INFO);
    UADP_SPT_NAME1NXT(GOP_CONFIG_TIMING_INFO,GOP_SETCONFIG_PARAM,pCfg,GOP_CONFIG_TIMING_INFO_A0);

    UADP_SPT_NAME0NXT(GOP_CONFIG_IS_PIXEL_ENABLE_A0,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_CONFIG_IS_PIXEL_ENABLE,GOP_SETCONFIG_PARAM,pCfg,GOP_CONFIG_IS_PIXEL_ENABLE_A0);

    UADP_SPT_NAME0NXT(GOP_CONFIG_GET_MAXFBNUM_A0,EN_GOP_DST_TYPE);
    UADP_SPT_NAME1NXT(GOP_CONFIG_GET_MAXFBNUM,GOP_SETCONFIG_PARAM,pCfg,GOP_CONFIG_GET_MAXFBNUM_A0);

    //MAPI_CMD_GOP_SET_PROPERTY:
    //MAPI_CMD_GOP_GET_PROPERTY:
    UADP_SPT_NAME0NXT(GOP_PROPERTY_MIUSEL_miusel,EN_GOP_SEL_TYPE);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_MIUSEL,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_MIUSEL_miusel);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_CONTRAST_RGB,GOP_CONTRAST);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_CONTRAST,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_CONTRAST_RGB);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_BRIGHTNESS_Bri,GOP_BRIGHTNESS);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_BRIGHTNESS,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_BRIGHTNESS_Bri);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_OUTPUT_COLOR_output,EN_GOP_OUTPUT_COLOR);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_OUTPUT_COLOR,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_OUTPUT_COLOR_output);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_UV_SWAP_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_UV_SWAP,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_UV_SWAP_bEn);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_YC_SWAP_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_YC_SWAP,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_YC_SWAP_bEn);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_HSTART_PanelHStr,MS_U16);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_HSTART,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_HSTART_PanelHStr);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_TRANSCOLOR_trans_clr,GOP_TRANSCOLOR);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_TRANSCOLOR,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_TRANSCOLOR_trans_clr);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_PROGRESSIVE_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_PROGRESSIVE,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_PROGRESSIVE_bEn);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_ALPHAINVERSE_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_ALPHAINVERSE,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_ALPHAINVERSE_bEn);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_PREALPHAMODE_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_PREALPHAMODE,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_PREALPHAMODE_bEn);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_FIELD_INVERSE_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_FIELD_INVERSE,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_FIELD_INVERSE_bEn);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_HSCALE_RATIO_Hscale,MS_U16);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_HSCALE_RATIO,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_HSCALE_RATIO_Hscale);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_VSCALE_RATIO_Vscale,MS_U16);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_VSCALE_RATIO,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_VSCALE_RATIO_Vscale);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_OUTPUT_TIMING_stInfo,ST_GOP_TIMING_INFO);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_OUTPUT_TIMING,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_OUTPUT_TIMING_stInfo);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_PIXELBASE_ENABLE_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_PIXELBASE_ENABLE,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_PIXELBASE_ENABLE_bEn);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_CLK_DstType,EN_GOP_DST_TYPE);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_CLK,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_CLK_DstType);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_FORCE_WRITE_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_FORCE_WRITE,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_FORCE_WRITE_bEn);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_BANK_FORCE_WRITE_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_BANK_FORCE_WRITE,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_BANK_FORCE_WRITE_bEn);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_3D_LR_EXCHANGE_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_3D_LR_EXCHANGE,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_3D_LR_EXCHANGE_u32);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_VE_OSD_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_VE_OSD,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_VE_OSD_bEn);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_OUTPUT_LAYER_SWITCH_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_OUTPUT_LAYER_SWITCH,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_OUTPUT_LAYER_SWITCH_u32);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_SWAP_OVERLAP_WIN_win,MS_U8);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_SWAP_OVERLAP_WIN,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_SWAP_OVERLAP_WIN_win);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_BW_STRENGTH_eGOPBWStr,EN_GOP_BW_STRENGTH);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_BW_STRENGTH,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_BW_STRENGTH_eGOPBWStr);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_LB_COUPLE_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_LB_COUPLE,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_LB_COUPLE_bEn);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_YUV_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_YUV,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_YUV_u32);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_REG_UPDATED_Updated,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_REG_UPDATED,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_REG_UPDATED_Updated);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_RELATIVE_WIN_PRIO_GwinPri,GOP_GwinPri);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_RELATIVE_WIN_PRIO,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_RELATIVE_WIN_PRIO_GwinPri);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_RESOURCE_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_RESOURCE,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_RESOURCE_u32);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_MAXFBNUM_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_MAXFBNUM,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_MAXFBNUM_u32);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_MULTI_ALPHA_ENABLE_A0,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_MULTI_ALPHA_ENABLE,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_MULTI_ALPHA_ENABLE_A0);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_AFBC_CORE_RESET_A0,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_AFBC_CORE_RESET,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_AFBC_CORE_RESET_A0);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_AFBC_CORE_EN_A0,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_AFBC_CORE_EN,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_AFBC_CORE_EN_A0);

    UADP_SPT_NAME0NXT(GOP_PROPERTY_TLB_ENABLE_A0,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_PROPERTY_TLB_ENABLE,GOP_SET_PROPERTY_PARAM,pSetting,GOP_PROPERTY_TLB_ENABLE_A0);

    #ifdef BIFROST_32BIT_MODE
        UADP_SDT_NAME2(GOP_INIT_pInfo_noparameter_init,GOP_InitInfo,UADP_SDT_AT,u32GOPRBAdr,MS_NULL,UADP_SDT_AT,u32GOPRegdmaAdr,MS_NULL);
    #else
        UADP_SDT_NAME0(GOP_INIT_pInfo_noparameter_init,GOP_InitInfo);
    #endif
    UADP_SPT_NAME1NXT(GOP_INIT_pInfo_noparameter,GOP_SET_PROPERTY_PARAM,pSetting,GOP_INIT_pInfo_noparameter_init);

    //MAPI_CMD_GOP_SET_DST:
    UADP_SPT_NAME0NXT(GOP_SETDST_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_SETDST,GOP_SETDST_PARAM,pDst,GOP_SETDST_u32);
    //MAPI_CMD_GOP_GET_DST:
    UADP_SPT_NAME0NXT(GOP_GETDST_dst,DRV_GOPDstType);
    UADP_SPT_NAME1NXT(GOP_GETDST,GOP_GETDST_PARAM,pDst,GOP_GETDST_dst);
    //MAPI_CMD_GOP_SET_MUX:
    UADP_SPT_NAME0NXT(GOP_SETMUX_MuxInfo,GOP_SETMUX);
    UADP_SPT_NAME1NXT(GOP_SETMUX,GOP_SETMUX_PARAM,pMuxInfo,GOP_SETMUX_MuxInfo);
    //MAPI_CMD_GOP_SET_LAYER:
    //MAPI_CMD_GOP_GET_LAYER:
    UADP_SPT_NAME0NXT(GOP_LAYER_LayerInfo,GOP_SETLayer);
    UADP_SPT_NAME1NXT(GOP_LAYER,GOP_SETLAYER_PARAM,pLayerInfo,GOP_LAYER_LayerInfo);
    //MAPI_CMD_GOP_SET_MIRROR:
    //MAPI_CMD_GOP_GET_MIRROR:
    UADP_SPT_NAME0NXT(GOP_MIRROR,GOP_SETMIRROR_PARAM);
    //MAPI_CMD_GOP_GET_STATUS:
    UADP_SPT_NAME0NXT(GOP_STATUS_INIT_Init,GOP_INIT_STATUS);
    UADP_SPT_NAME1NXT(GOP_STATUS_INIT,GOP_GET_STATUS_PARAM,pStatus,GOP_STATUS_INIT_Init);

    UADP_SPT_NAME0NXT(GOP_STATUS_GOP_MAXNUM_MaxGopNum,MS_U8);
    UADP_SPT_NAME1NXT(GOP_STATUS_GOP_MAXNUM,GOP_GET_STATUS_PARAM,pStatus,GOP_STATUS_GOP_MAXNUM_MaxGopNum);

    UADP_SPT_NAME0NXT(GOP_STATUS_GWIN_MAXNUM_GOP_GWIN_NUM,GOP_GWIN_NUM);
    UADP_SPT_NAME1NXT(GOP_STATUS_GWIN_MAXNUM,GOP_GET_STATUS_PARAM,pStatus,GOP_STATUS_GWIN_MAXNUM_GOP_GWIN_NUM);

    UADP_SPT_NAME0NXT(GOP_STATUS_GWIN_TOTALNUM_GwinNum,MS_U8);
    UADP_SPT_NAME1NXT(GOP_STATUS_GWIN_TOTALNUM,GOP_GET_STATUS_PARAM,pStatus,GOP_STATUS_GWIN_TOTALNUM_GwinNum);

    UADP_SPT_NAME0NXT(GOP_STATUS_VERSION_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_STATUS_VERSION,GOP_GET_STATUS_PARAM,pStatus,GOP_STATUS_VERSION_u32);

    UADP_SPT_NAME0NXT(GOP_STATUS_MUX_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_STATUS_MUX,GOP_GET_STATUS_PARAM,pStatus,GOP_STATUS_MUX_u32);

    UADP_SPT_NAME0NXT(GOP_STATUS_CURRENT_GOP_CurrentGop, MS_U32);
    UADP_SPT_NAME1NXT(GOP_STATUS_CURRENT_GOP,GOP_GET_STATUS_PARAM,pStatus,GOP_STATUS_CURRENT_GOP_CurrentGop);

    UADP_SPT_NAME0NXT(GOP_STATUS_CURRENT_GWIN_CurrentGwin,MS_U32);
    UADP_SPT_NAME1NXT(GOP_STATUS_CURRENT_GWIN,GOP_GET_STATUS_PARAM,pStatus,GOP_STATUS_CURRENT_GWIN_CurrentGwin);

    UADP_SPT_NAME0NXT(GOP_STATUS_CURRENT_FBID_CurrentFbid,MS_U32);
    UADP_SPT_NAME1NXT(GOP_STATUS_CURRENT_FBID,GOP_GET_STATUS_PARAM,pStatus,GOP_STATUS_CURRENT_FBID_CurrentFbid);
    //MAPI_CMD_GOP_GWIN_SET_STRETCH:
    //MAPI_CMD_GOP_GWIN_GET_STRETCH:
    UADP_SPT_NAME0NXT(GOP_STRETCH_Stretch,GOP_STRETCH_INFO);
    UADP_SPT_NAME1NXT(GOP_STRETCH,GOP_STRETCH_SET_PARAM,pStretch,GOP_STRETCH_Stretch);
    //MAPI_CMD_GOP_GWIN_SET_PROPERTY:
    //MAPI_CMD_GOP_GWIN_GET_PROPERTY:
    UADP_SPT_NAME0NXT(GOP_GWIN_PROPERTY_BLENDING_bEn,GOP_GWIN_BLENDING);
    UADP_SPT_NAME1NXT(GOP_GWIN_PROPERTY_BLENDING,GOP_GWIN_PROPERTY_PARAM,pSet,GOP_GWIN_PROPERTY_BLENDING_bEn);

    UADP_SPT_NAME0NXT(GOP_GWIN_PROPERTY_NEWAPLHA_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_GWIN_PROPERTY_NEWAPLHA,GOP_GWIN_PROPERTY_PARAM,pSet,GOP_GWIN_PROPERTY_NEWAPLHA_bEn);

    UADP_SPT_NAME0NXT(GOP_GWIN_PROPERTY_ENABLE_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_GWIN_PROPERTY_ENABLE,GOP_GWIN_PROPERTY_PARAM,pSet,GOP_GWIN_PROPERTY_ENABLE_bEn);

    UADP_SPT_NAME0NXT(GOP_GWIN_PROPERTY_BLINK_Rate,GOP_GWIN_BLINK);
    UADP_SPT_NAME1NXT(GOP_GWIN_PROPERTY_BLINK,GOP_GWIN_PROPERTY_PARAM,pSet,GOP_GWIN_PROPERTY_BLINK_Rate);

    UADP_SPT_NAME0NXT(GOP_GWIN_PROPERTY_SHARE_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_GWIN_PROPERTY_SHARE,GOP_GWIN_PROPERTY_PARAM,pSet,GOP_GWIN_PROPERTY_SHARE_bEn);

    UADP_SPT_NAME0NXT(GOP_GWIN_PROPERTY_SHARE_CNT_SharedCnt,MS_U16);
    UADP_SPT_NAME1NXT(GOP_GWIN_PROPERTY_SHARE_CNT,GOP_GWIN_PROPERTY_PARAM,pSet,GOP_GWIN_PROPERTY_SHARE_CNT_SharedCnt);

    UADP_SPT_NAME0NXT(GOP_GWIN_PROPERTY_SWITCH_2_GWIN_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_GWIN_PROPERTY_SWITCH_2_GWIN,GOP_GWIN_PROPERTY_PARAM,pSet,GOP_GWIN_PROPERTY_SWITCH_2_GWIN_u32);

    UADP_SPT_NAME0NXT(GOP_GWIN_PROPERTY_3D_MODE_3DMode,GOP_GWIN_3D_MODE);
    UADP_SPT_NAME1NXT(GOP_GWIN_PROPERTY_3D_MODE,GOP_GWIN_PROPERTY_PARAM,pSet,GOP_GWIN_PROPERTY_3D_MODE_3DMode);

    UADP_SPT_NAME0NXT(GOP_GWIN_PROPERTY_EXIST_Exist,MS_U8);
    UADP_SPT_NAME1NXT(GOP_GWIN_PROPERTY_EXIST,GOP_GWIN_PROPERTY_PARAM,pSet,GOP_GWIN_PROPERTY_EXIST_Exist);

    UADP_SPT_NAME0NXT(GOP_GWIN_PROPERTY_FREE_ID_FreeId,MS_U8);
    UADP_SPT_NAME1NXT(GOP_GWIN_PROPERTY_FREE_ID,GOP_GWIN_PROPERTY_PARAM,pSet,GOP_GWIN_PROPERTY_FREE_ID_FreeId);

    UADP_SPT_NAME0NXT(GOP_GWIN_PROPERTY_GET_FB_FbId,MS_U32);
    UADP_SPT_NAME1NXT(GOP_GWIN_PROPERTY_GET_FB,GOP_GWIN_PROPERTY_PARAM,pSet,GOP_GWIN_PROPERTY_GET_FB_FbId);

    UADP_SPT_NAME0NXT(GOP_GWIN_PROPERTY_GET_GOP_GOP,MS_U32);
    UADP_SPT_NAME1NXT(GOP_GWIN_PROPERTY_GET_GOP,GOP_GWIN_PROPERTY_PARAM,pSet,GOP_GWIN_PROPERTY_GET_GOP_GOP);

    UADP_SPT_NAME0NXT(GOP_GWIN_PROPERTY_GOPTILE_A0,EN_GOP_GPU_TILE_MODE);
    UADP_SPT_NAME1NXT(GOP_GWIN_PROPERTY_GOPTILE,GOP_GWIN_PROPERTY_PARAM,pSet,GOP_GWIN_PROPERTY_GOPTILE_A0);

    //MAPI_CMD_GOP_GWIN_MAPFB2WIN:
    UADP_SPT_NAME0NXT(GOP_GWIN_MAPFBINFO_Set,MS_U32);
    UADP_SPT_NAME1NXT(GOP_GWIN_MAPFBINFO,GOP_GWIN_MAPFBINFO_PARAM,pinfo,GOP_GWIN_MAPFBINFO_Set);
    //MAPI_CMD_GOP_GWIN_SET_WININFO:
    //MAPI_CMD_GOP_GWIN_GET_WININFO:
#ifdef BIFROST_32BIT_MODE
    UADP_SDT_NAME1(GOP_GWIN_SETWININFO_info,GOP_BUFFER_INFO,UADP_SDT_AT,addr,MS_NULL);
#else
    UADP_SDT_NAME0(GOP_GWIN_SETWININFO_info,GOP_BUFFER_INFO);
#endif
    UADP_SPT_NAME1NXT(GOP_GWIN_SETWININFO,GOP_GWIN_SETWININFO_PARAM,pinfo,GOP_GWIN_SETWININFO_info);
    //MAPI_CMD_GOP_GWIN_SETDISPLAY:
#ifdef BIFROST_32BIT_MODE
    UADP_SDT_NAME1(GOP_GwinInfo_A0,GOP_GwinInfo,UADP_SDT_AT,u32DRAMRBlkStart,MS_NULL);
#else
    UADP_SDT_NAME0(GOP_GwinInfo_A0,GOP_GwinInfo);
#endif
    UADP_SDT_NAME1(GOP_GWIN_DISPLAY_DisplayInfo,GOP_GWINDISPLAY_INFO,UADP_SDT_ES,gwin_info,GOP_GwinInfo_A0);
    UADP_SPT_NAME1NXT(GOP_GWIN_DISPLAY,GOP_GWIN_DISPLAY_PARAM,pDisplayInfo,GOP_GWIN_DISPLAY_DisplayInfo);
    //MAPI_CMD_GOP_GWIN_DESTROY:
    UADP_SPT_NAME0NXT(GOP_GWIN_DESTROY_ptr,MS_U32);
    UADP_SPT_NAME1NXT(GOP_GWIN_DESTROY,GOP_GWIN_DESTROY_PARAM,ptr,GOP_GWIN_DESTROY_ptr);
    //MAPI_CMD_GOP_GFLIP_CLEARQUEUE:
    UADP_SPT_NAME0NXT(GOP_GWIN_CLEARQUEUE_ClearInfo,GOP_GWIN_CLEARQUEUE_INFO);
    UADP_SPT_NAME1NXT(GOP_GWIN_CLEARQUEUE,GOP_GWIN_CLEARQUEUE_PARAM,pClearInfo,GOP_GWIN_CLEARQUEUE_ClearInfo);
    //MAPI_CMD_GOP_GFLIP_SWITCHGWIN:
    UADP_SPT_NAME0NXT(GOP_GWIN_GFLIP_SWITCH_GWIN_FlipInfo_pQueueCnt,MS_U32);
#ifdef BIFROST_32BIT_MODE
    UADP_SDT_NAME3(GOP_GWIN_GFLIP_SWITCH_GWIN_FlipInfo,GOP_GWIN_FLIP_WIN_INFO,UADP_SDT_AT,FlipAddr,MS_NULL, UADP_SDT_AT,SubFlipAddr,MS_NULL,UADP_SDT_P2N,pQueueCnt,GOP_GWIN_GFLIP_SWITCH_GWIN_FlipInfo_pQueueCnt);
#else
    UADP_SDT_NAME1(GOP_GWIN_GFLIP_SWITCH_GWIN_FlipInfo,GOP_GWIN_FLIP_WIN_INFO,UADP_SDT_P2N,pQueueCnt,GOP_GWIN_GFLIP_SWITCH_GWIN_FlipInfo_pQueueCnt);
#endif
    UADP_SPT_NAME1NXT(GOP_GWIN_GFLIP_SWITCH_GWIN,GOP_GWIN_GFLIP_SWITCH_GWIN_PARAM,pFlipInfo,GOP_GWIN_GFLIP_SWITCH_GWIN_FlipInfo);
    //MAPI_CMD_GOP_GFLIP_SWITCHMULTIGWIN:
    UADP_SDT_NAME3(GOP_GWIN_GFLIP_SWITCH_MULTI_Info,GOP_GWIN_FLIP_WIN_INFO, UADP_SDT_AT,FlipAddr,MS_NULL, UADP_SDT_AT, SubFlipAddr, MS_NULL, UADP_SDT_AT, pQueueCnt,MS_NULL);
    UADP_SPT_NAME1NXT(GOP_GWIN_GFLIP_SWITCH_MULTI_GWIN_MultiFlipInfo,GOP_GWIN_FLIP_MULTI_WIN_INFO, FlipInfo[0], GOP_GWIN_GFLIP_SWITCH_MULTI_Info);
    UADP_SPT_NAME1NXT(GOP_GWIN_GFLIP_SWITCH_MULTI_GWIN,GOP_GWIN_GFLIP_SWITCH_MULTI_GWIN_PARAM,pMultiFlipInfo,GOP_GWIN_GFLIP_SWITCH_MULTI_GWIN_MultiFlipInfo);
    //MAPI_CMD_GOP_GFLIP_RESTORE_VSYNC_LMT:
    //MAPI_CMD_GOP_SET_PINPON:
    UADP_SPT_NAME0NXT(GOP_SET_PINPON_PINPON_PINPONInfo,GOP_SET_PINPON_INFO);
    UADP_SPT_NAME1NXT(GOP_SET_PINPON_PINPON,GOP_SET_PINPON_PARAM,pSetting,GOP_SET_PINPON_PINPON_PINPONInfo);
    //MAPI_CMD_GOP_FB_CREATE:
#ifdef BIFROST_32BIT_MODE
    UADP_SDT_NAME1(GOP_CREATE_BUFFER_BufInfo,GOP_BUFFER_INFO,UADP_SDT_AT,addr,MS_NULL);
#else
    UADP_SDT_NAME0(GOP_CREATE_BUFFER_BufInfo,GOP_BUFFER_INFO);
#endif
    UADP_SPT_NAME1NXT(GOP_CREATE_BUFFER,GOP_CREATE_BUFFER_PARAM,pBufInfo,GOP_CREATE_BUFFER_BufInfo);
    //MAPI_CMD_GOP_FB_DESTROY:
    UADP_SPT_NAME0NXT(GOP_DELETE_BUFFER_BufId,MS_U32);
    UADP_SPT_NAME1NXT(GOP_DELETE_BUFFER,GOP_DELETE_BUFFER_PARAM,pBufId,GOP_DELETE_BUFFER_BufId);
    //MAPI_CMD_GOP_FB_GETINFO:
    //MAPI_CMD_GOP_FB_SETINFO:
#ifdef BIFROST_32BIT_MODE
    UADP_SDT_NAME1(GOP_FB_INFO_BufInfo,GOP_BUFFER_INFO,UADP_SDT_AT,addr,MS_NULL);
#else
    UADP_SDT_NAME0(GOP_FB_INFO_BufInfo,GOP_BUFFER_INFO);
#endif
    UADP_SPT_NAME1NXT(GOP_FB_INFO,GOP_FB_INFO_PARAM,pBufInfo,GOP_FB_INFO_BufInfo);
    //////////////////////////////////////////////////
    //MAPI_CMD_GOP_FB_SET_PROPERTY:
    //MAPI_CMD_GOP_FB_GET_PROPERTY:
    UADP_SPT_NAME0NXT(GOP_FB_PROPERTY_POOLID_Pool,MS_U32);
    UADP_SPT_NAME1NXT(GOP_FB_PROPERTY_POOLID,GOP_FB_PROPERTY_PARAM,pSet,GOP_FB_PROPERTY_POOLID_Pool);

    UADP_SPT_NAME0NXT(GOP_FB_PROPERTY_EXIST_Exist,MS_U32);
    UADP_SPT_NAME1NXT(GOP_FB_PROPERTY_EXIST,GOP_FB_PROPERTY_PARAM,pSet,GOP_FB_PROPERTY_EXIST_Exist);

    UADP_SPT_NAME0NXT(GOP_FB_PROPERTY_OBTAIN_1,MS_U32);
    UADP_SPT_NAME1NXT(GOP_FB_PROPERTY_OBTAIN,GOP_FB_PROPERTY_PARAM,pSet,GOP_FB_PROPERTY_OBTAIN_1);
    //MAPI_CMD_GOP_PALETTE_SET_CONFIG:
    UADP_SPT_NAME0NXT(GOP_PALETTE_CONFIG_PaletteInfo,GOP_PAL_OPT);
    UADP_SPT_NAME1NXT(GOP_PALETTE_CONFIG,GOP_PALETTE_CONFIG_PARAM,pPaletteInfo,GOP_PALETTE_CONFIG_PaletteInfo);
    //MAPI_CMD_GOP_PALETTE_SET_ENTRY:
    //MAPI_CMD_GOP_PALETTE_GET_ENTRY:
    UADP_SDT_NAME1(GOP_PALETTE_SET_ENTRY_A0,GOP_PALETTE_ENTRY ,UADP_SDT_P2N,pClut,GOP_PALETTE_SET_ENTRY_A0B0);
    UADP_SDT_NAME1(GOP_PALETTE_SET_ENTRY,GOP_PALETTE_SET_PARAM,UADP_SDT_P2N,pClut,GOP_PALETTE_SET_ENTRY_A0);

    //MAPI_CMD_GOP_SET_SCROLL:
    UADP_SPT_NAME0NXT(GOP_SCROLL_CONFIG_ScrollInfo,GOP_SCROLL_INFO);
    UADP_SPT_NAME1NXT(GOP_SCROLL_CONFIG,GOP_SCROLL_PARAM,pCfg,GOP_SCROLL_CONFIG_ScrollInfo);

    UADP_SPT_NAME0NXT(GOP_SCROLL_RATE_rate,MS_U8);
    UADP_SPT_NAME1NXT(GOP_SCROLL_RATE,GOP_SCROLL_PARAM,pCfg,GOP_SCROLL_RATE_rate);
    //MAPI_CMD_GOP_GWIN_SET_FADE:
    UADP_SPT_NAME0NXT(GOP_SET_FADE_CONFIG_FadeInfo,GOP_FADE_INFO);
    UADP_SPT_NAME1NXT(GOP_SET_FADE_CONFIG,GOP_SET_FADE_PARAM,pSetting,GOP_SET_FADE_CONFIG_FadeInfo);
    //MAPI_CMD_GOP_DWIN_INIT:

    //MAPI_CMD_GOP_DWIN_CAPTURE:
#ifdef BIFROST_32BIT_MODE
    UADP_SDT_NAME4(GOP_DWIN_CAPTURE_Dwin,GOP_CAPTURE_INFO,UADP_SDT_AT,addr[0],MS_NULL, UADP_SDT_AT,addr[1],MS_NULL,UADP_SDT_AT,addr1[0],MS_NULL, UADP_SDT_AT,addr1[1],MS_NULL);
#else
    UADP_SDT_NAME0(GOP_DWIN_CAPTURE_Dwin,GOP_CAPTURE_INFO);
#endif
    UADP_SPT_NAME1NXT(GOP_DWIN_CAPTURE,GOP_DWIN_CAPTURE_PARAM,pDwin,GOP_DWIN_CAPTURE_Dwin);
    //MAPI_CMD_GOP_DWIN_INTR:
    UADP_SPT_NAME0NXT(GOP_DWIN_INTR_STATUS_CONTROL_IntrCtrl,GOP_DWIN_INTR_CTRL);
    UADP_SPT_NAME1NXT(GOP_DWIN_INTR_STATUS_CONTROL,GOP_DWIN_INTR_STATUS_PARAM,pIntrInfo,GOP_DWIN_INTR_STATUS_CONTROL_IntrCtrl);

    UADP_SPT_NAME0NXT(GOP_DWIN_INTR_STATUS_GETINFO_Intr,MS_U16);
    UADP_SPT_NAME1NXT(GOP_DWIN_INTR_STATUS_GETINFO,GOP_DWIN_INTR_STATUS_PARAM,pIntrInfo,GOP_DWIN_INTR_STATUS_GETINFO_Intr);

    UADP_SPT_NAME0NXT(GOP_DWIN_INTR_STATUS_GETINFO_TIMEOUT_Timeout,GOP_DWIN_INTR_TIME_OUT);
    UADP_SPT_NAME1NXT(GOP_DWIN_INTR_STATUS_GETINFO_TIMEOUT,GOP_DWIN_INTR_STATUS_PARAM,pIntrInfo,GOP_DWIN_INTR_STATUS_GETINFO_TIMEOUT_Timeout);
    //MAPI_CMD_GOP_DWIN_SET_PROPERTY:
    //MAPI_CMD_GOP_DWIN_GET_PROPERTY:
    UADP_SPT_NAME0NXT(GOP_DWIN_PROPERTY_R2Y_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_DWIN_PROPERTY_R2Y,GOP_DWIN_PROPERTY_PARAM,pDwinProp,GOP_DWIN_PROPERTY_R2Y_bEn);

    UADP_SPT_NAME0NXT(GOP_DWIN_PROPERTY_UV_SWAP_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_DWIN_PROPERTY_UV_SWAP,GOP_DWIN_PROPERTY_PARAM,pDwinProp,GOP_DWIN_PROPERTY_UV_SWAP_bEn);

    UADP_SPT_NAME0NXT(GOP_DWIN_PROPERTY_UV_SAMPLE_enMode,EN_GOP_DWIN_UVSAMPLE_Mode);
    UADP_SPT_NAME1NXT(GOP_DWIN_PROPERTY_UV_SAMPLE,GOP_DWIN_PROPERTY_PARAM,pDwinProp,GOP_DWIN_PROPERTY_UV_SAMPLE_enMode);

    UADP_SPT_NAME0NXT(GOP_DWIN_PROPERTY_SOURCE_SCAN_TYPE_enMode,EN_GOP_DWIN_SCAN_MODE);
    UADP_SPT_NAME1NXT(GOP_DWIN_PROPERTY_SOURCE_SCAN_TYPE,GOP_DWIN_PROPERTY_PARAM,pDwinProp,GOP_DWIN_PROPERTY_SOURCE_SCAN_TYPE_enMode);

    UADP_SPT_NAME0NXT(GOP_DWIN_PROPERTY_ALPHA_VALUE_Value,MS_U8);
    UADP_SPT_NAME1NXT(GOP_DWIN_PROPERTY_ALPHA_VALUE,GOP_DWIN_PROPERTY_PARAM,pDwinProp,GOP_DWIN_PROPERTY_ALPHA_VALUE_Value);

    UADP_SPT_NAME0NXT(GOP_DWIN_PROPERTY_ALPHA_SOURCE_enSource,EN_GOP_DWIN_ALPHA_SRC);
    UADP_SPT_NAME1NXT(GOP_DWIN_PROPERTY_ALPHA_SOURCE,GOP_DWIN_PROPERTY_PARAM,pDwinProp,GOP_DWIN_PROPERTY_ALPHA_SOURCE_enSource);

    UADP_SPT_NAME0NXT(GOP_DWIN_PROPERTY_ALPHA_INVERSE_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_DWIN_PROPERTY_ALPHA_INVERSE,GOP_DWIN_PROPERTY_PARAM,pDwinProp,GOP_DWIN_PROPERTY_ALPHA_INVERSE_bEn);

    UADP_SPT_NAME0NXT(GOP_DWIN_PROPERTY_SKIP_FRAME_Count,MS_U32);
    UADP_SPT_NAME1NXT(GOP_DWIN_PROPERTY_SKIP_FRAME,GOP_DWIN_PROPERTY_PARAM,pDwinProp,GOP_DWIN_PROPERTY_SKIP_FRAME_Count);

#ifdef BIFROST_32BIT_MODE
    UADP_SDT_NAME2(GOP_DWIN_PROPERTY_PINPON_Pinpon,GOP_PINPON_INFO,UADP_SDT_AT,u64Addr0,MS_NULL,UADP_SDT_AT,u64Addr1,MS_NULL);
#else
    UADP_SDT_NAME0(GOP_DWIN_PROPERTY_PINPON_Pinpon,GOP_PINPON_INFO);
#endif
    UADP_SPT_NAME1NXT(GOP_DWIN_PROPERTY_PINPON,GOP_DWIN_PROPERTY_PARAM,pDwinProp,GOP_DWIN_PROPERTY_PINPON_Pinpon);

    UADP_SPT_NAME0NXT(GOP_DWIN_PROPERTY_INTERRUP_INFO_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_DWIN_PROPERTY_INTERRUP_INFO,GOP_DWIN_PROPERTY_PARAM,pDwinProp,GOP_DWIN_PROPERTY_INTERRUP_INFO_u32);

    UADP_SPT_NAME0NXT(GOP_DWIN_PROPERTY_CAPTURE_INFO_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_DWIN_PROPERTY_CAPTURE_INFO,GOP_DWIN_PROPERTY_PARAM,pDwinProp,GOP_DWIN_PROPERTY_CAPTURE_INFO_u32);
    //MAPI_CMD_GOP_MIXER_SET_PROPERTY:
    //MAPI_CMD_GOP_MIXER_GET_PROPERTY:
    UADP_SPT_NAME0NXT(GOP_MIXER_PROPERTY_OUTPUT_TIMING_MTInfo,GOP_MIXER_TIMING_INFO);
    UADP_SPT_NAME1NXT(GOP_MIXER_PROPERTY_OUTPUT_TIMING,GOP_MIXER_PROPERTY_PARAM,pMixerProp,GOP_MIXER_PROPERTY_OUTPUT_TIMING_MTInfo);

    UADP_SPT_NAME0NXT(GOP_MIXER_PROPERTY_TO_OP_OUTPUT_TIMING_MT,GOP_Mixer2OPTiming);
    UADP_SPT_NAME1NXT(GOP_MIXER_PROPERTY_TO_OP_OUTPUT_TIMING,GOP_MIXER_PROPERTY_PARAM,pMixerProp,GOP_MIXER_PROPERTY_TO_OP_OUTPUT_TIMING_MT);

    UADP_SPT_NAME0NXT(GOP_MIXER_PROPERTY_V_FILTER_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_MIXER_PROPERTY_V_FILTER,GOP_MIXER_PROPERTY_PARAM,pMixerProp,GOP_MIXER_PROPERTY_V_FILTER_bEn);

    UADP_SPT_NAME0NXT(GOP_MIXER_PROPERTY_OLD_BLENDING_MODE_MOBM,GOP_MixerOldBlendingMode);
    UADP_SPT_NAME1NXT(GOP_MIXER_PROPERTY_OLD_BLENDING_MODE,GOP_MIXER_PROPERTY_PARAM,pMixerProp,GOP_MIXER_PROPERTY_OLD_BLENDING_MODE_MOBM);
    //MAPI_CMD_GOP_VE_SET_PROPERTY:
    UADP_SPT_NAME0NXT(GOP_VE_PROPERTY_OUTPUT_TIMING_VEInfo,GOP_VE_TIMING_INFO);
    UADP_SPT_NAME1NXT(GOP_VE_PROPERTY_OUTPUT_TIMING,GOP_VE_PROPERTY_PARAM,pVEProp,GOP_VE_PROPERTY_OUTPUT_TIMING_VEInfo);
    //MAPI_CMD_GOP_UPDATE:
    UADP_SPT_NAME0NXT(GOP_UPDATE_UpdateInfo,GOP_UPDATE_INFO);
    UADP_SPT_NAME1NXT(GOP_UPDATE,GOP_UPDATE_PARAM,pUpdateInfo,GOP_UPDATE_UpdateInfo);
    //MAPI_CMD_GOP_REGISTER_CB:
    UADP_SPT_NAME0NXT(GOP_CB_INTERLACE_A0, MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_CB_INTERLACE,GOP_REGISTER_CB_PARAM,pCB,GOP_CB_INTERLACE_A0);

    UADP_SPT_NAME0NXT(GOP_CB_HSTART_A0, MS_U32);
    UADP_SPT_NAME1NXT(GOP_CB_HSTART,GOP_REGISTER_CB_PARAM,pCB,GOP_CB_HSTART_A0);
    //MAPI_CMD_GOP_TESTPATTERN:
    UADP_SPT_NAME0NXT(GOP_TESTPATTERN, GOP_TEST_PATTERN_PARAM);
    //MAPI_CMD_GOP_SELECTION:
    UADP_SPT_NAME0NXT(GOP_SELECTION_SELGOP_A0, MS_U32);
    UADP_SPT_NAME1NXT(GOP_SELECTION_SELGOP,GOP_SELECTION_PROPERTY_PARAM,pinfo,GOP_SELECTION_SELGOP_A0);

    UADP_SPT_NAME0NXT(GOP_SELECTION_SELGWIN_A0, MS_U32);
    UADP_SPT_NAME1NXT(GOP_SELECTION_SELGWIN,GOP_SELECTION_PROPERTY_PARAM,pinfo,GOP_SELECTION_SELGWIN_A0);

#ifdef BIFROST_32BIT_MODE
    UADP_SDT_NAME1(GOP_SELECTION_SELFB_A0, GOP_CBFmtInfo,UADP_SDT_AT,u64Addr,MS_NULL);
    UADP_SPT_NAME1NXT(GOP_SELECTION_SELFB,GOP_SELECTION_PROPERTY_PARAM,pinfo,GOP_SELECTION_SELFB_A0);
#else
    UADP_SPT_NAME0NXT(GOP_SELECTION_SELFB_A0, GOP_CBFmtInfo);
    UADP_SPT_NAME1NXT(GOP_SELECTION_SELFB,GOP_SELECTION_PROPERTY_PARAM,pinfo,GOP_SELECTION_SELFB_A0);
#endif
    //MAPI_CMD_GOP_MUTEX:
    UADP_SPT_NAME0NXT(GOP_MUTEX_pSet,MS_U32);
    UADP_SPT_NAME1NXT(GOP_MUTEX,GOP_MUTEX_PARAM,pSet,GOP_MUTEX_pSet);
    //MAPI_CMD_GOP_MISC:
    UADP_SPT_NAME0NXT(GOP_MISC_ENABLE_T3D_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_MISC_ENABLE_T3D,GOP_MISC_PARAM,pMISC,GOP_MISC_ENABLE_T3D_bEn);

    UADP_SPT_NAME0NXT(GOP_MISC_SET_CAPTURE_CLK_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_MISC_SET_CAPTURE_CLK,GOP_MISC_PARAM,pMISC,GOP_MISC_SET_CAPTURE_CLK_u32);


    UADP_SPT_NAME0NXT(GOP_MISC_POWER_OFF_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_MISC_POWER_OFF,GOP_MISC_PARAM,pMISC,GOP_MISC_POWER_OFF_u32);


    UADP_SPT_NAME0NXT(GOP_MISC_POWER_ON_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_MISC_POWER_ON,GOP_MISC_PARAM,pMISC,GOP_MISC_POWER_ON_u32);

    UADP_SPT_NAME0NXT(GOP_MISC_GET_RT_STATUS_GopApiSts,GOP_ApiStatus);
    UADP_SPT_NAME1NXT(GOP_MISC_GET_RT_STATUS,GOP_MISC_PARAM,pMISC,GOP_MISC_GET_RT_STATUS_GopApiSts);

    UADP_SPT_NAME0NXT(GOP_MISC_GET_INFO_GopApiInfo,GOP_ApiInfo);
    UADP_SPT_NAME1NXT(GOP_MISC_GET_INFO,GOP_MISC_PARAM,pMISC,GOP_MISC_GET_INFO_GopApiInfo);

    UADP_SPT_NAME0NXT(GOP_MISC_AT_EXIT_u32,MS_U32);
    UADP_SPT_NAME1NXT(GOP_MISC_AT_EXIT,GOP_MISC_PARAM,pMISC,GOP_MISC_AT_EXIT_u32);

    UADP_SPT_NAME0NXT(GOP_MISC_OC_FB_INFO_OCFbInfo,GOP_OC_FB_INFO);
    UADP_SPT_NAME1NXT(GOP_MISC_OC_FB_INFO,GOP_MISC_PARAM,pMISC,GOP_MISC_OC_FB_INFO_OCFbInfo);

    UADP_SPT_NAME0NXT(GOP_MISC_TESTPATTERN_ALPHA_bEn,MS_BOOL);
    UADP_SPT_NAME1NXT(GOP_MISC_TESTPATTERN_ALPHA,GOP_MISC_PARAM,pMISC,GOP_MISC_TESTPATTERN_ALPHA_bEn);

    UADP_SPT_NAME0NXT(GOP_MISC_DELETE_GWINSIZE_A0, GOP_DeleteWinSize_PARAM);
    UADP_SPT_NAME1NXT(GOP_MISC_DELETE_GWINSIZE,GOP_MISC_PARAM,pMISC,GOP_MISC_DELETE_GWINSIZE_A0);
    //MAPI_CMD_GOP_RESETPOOL:

    UADP_SPT_NAME0NXT(GOP_POWERSTATE_PARAM_A0, MS_U32);
    UADP_SPT_NAME1NXT(GOP_POWERSTATE_PARAM,GOP_POWERSTATE_PARAM,pInfo,GOP_POWERSTATE_PARAM_A0);

	*pIoctl= (FUtopiaIOctl)GOP_adp_Ioctl;

    return 0;
}

MS_U32 GOP_adp_Ioctl(void* pInstanceTmp, MS_U32 u32Cmd, void* const pArgs)
{
    MS_U32 u32Ret=UTOPIA_STATUS_SUCCESS;
	char buffer_arg[2048];
    switch(u32Cmd)
    {
        //gop property
        case MAPI_CMD_GOP_INIT:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_INIT, spt_GOP_INIT,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_GET_CHIPCAPS:
            {
                GOP_GETCAPS_PARAM ptr;
                if(copy_from_user(&ptr, (GOP_GETCAPS_PARAM __user *)pArgs, sizeof(GOP_GETCAPS_PARAM)))
                {
                    return UTOPIA_STATUS_FAIL;
                }
                switch(ptr.caps)
                {
                    case E_GOP_CAP_WORD_UNIT:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GETCAPS_WORD_UNIT,spt_GOP_GETCAPS_WORD_UNIT,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_CAP_GWIN_NUM:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GETCAPS_GWIN_NUM,spt_GOP_GETCAPS_GWIN_NUM,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_CAP_VERSION:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GETCAPS_VERSION,spt_GOP_GETCAPS_VERSION,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_CAP_RESERVED:
                        printk("E_GOP_IS_PIXELBASE_ENABLE not implement\n");
                        break;
                    case E_GOP_CAP_CONSALPHA_VALIDBITS:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GETCAPS_CONSALPHA_VALIDBITS,spt_GOP_GETCAPS_CONSALPHA_VALIDBITS,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_CAP_PALETTE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GETCAPS_PALETTE,spt_GOP_GETCAPS_PALETTE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_CAP_DWIN:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GETCAPS_DWIN,spt_GOP_GETCAPS_DWIN,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_CAP_GOP_MUX:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GETCAPS_GOP_MUX,spt_GOP_GETCAPS_GOP_MUX,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_CAP_PIXELMODE_SUPPORT:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GETCAPS_PIXELMODE_SUPPORT,spt_GOP_GETCAPS_PIXELMODE_SUPPORT,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_CAP_STRETCH:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GETCAPS_STRETCH,spt_GOP_GETCAPS_STRETCH,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_CAP_AFBC_SUPPORT:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GETCAPS_SUPPORT_AFBC,spt_GOP_GETCAPS_SUPPORT_AFBC,buffer_arg,sizeof(buffer_arg));
                        break;
                }
                break;
            }
        case MAPI_CMD_GOP_SET_CONFIG:
        case MAPI_CMD_GOP_GET_CONFIG:
            {
                GOP_SETCONFIG_PARAM ptr;
                if(copy_from_user(&ptr, (GOP_SETCONFIG_PARAM __user *)pArgs, sizeof(GOP_SETCONFIG_PARAM)))
                {
                    return UTOPIA_STATUS_FAIL;
                }
                switch(ptr.cfg_type)
                {
                    case E_GOP_IGNOREINIT:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_CONFIG_IGNOREINIT,spt_GOP_CONFIG_IGNOREINIT,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_CONSALPHA_BITS:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_CONFIG_CONSALPHA_BITS,spt_GOP_CONFIG_CONSALPHA_BITS,buffer_arg,sizeof(buffer_arg));
                        break;
                   case E_GOP_TIMING_INFO:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_CONFIG_TIMING_INFO,spt_GOP_CONFIG_TIMING_INFO,buffer_arg,sizeof(buffer_arg));
                        break;
                   case E_GOP_IS_PIXELBASE_ENABLE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_CONFIG_IS_PIXEL_ENABLE,spt_GOP_CONFIG_IS_PIXEL_ENABLE,buffer_arg,sizeof(buffer_arg));
                        break;
                   case E_GOP_GET_MAXFBNUM:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_CONFIG_GET_MAXFBNUM,spt_GOP_CONFIG_GET_MAXFBNUM,buffer_arg,sizeof(buffer_arg));
                        break;
                }
                break;
            }
        case MAPI_CMD_GOP_SET_PROPERTY:
        case MAPI_CMD_GOP_GET_PROPERTY:
           {
                GOP_SET_PROPERTY_PARAM ptr;
                if(copy_from_user(&ptr, (GOP_SET_PROPERTY_PARAM __user *)pArgs, sizeof(GOP_SET_PROPERTY_PARAM)))
                {
                    return UTOPIA_STATUS_FAIL;
                }
                switch(ptr.en_pro)
                {
                    case E_GOP_MIUSEL:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_MIUSEL,spt_GOP_PROPERTY_MIUSEL,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_CONTRAST:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_CONTRAST,spt_GOP_PROPERTY_CONTRAST,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_BRIGHTNESS:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_BRIGHTNESS,spt_GOP_PROPERTY_BRIGHTNESS,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_OUTPUT_COLOR:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_OUTPUT_COLOR,spt_GOP_PROPERTY_OUTPUT_COLOR,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_UV_SWAP:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_UV_SWAP,spt_GOP_PROPERTY_UV_SWAP,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_YC_SWAP:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_YC_SWAP,spt_GOP_PROPERTY_YC_SWAP,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_HSTART:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_HSTART,spt_GOP_PROPERTY_HSTART,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_TRANSCOLOR:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_TRANSCOLOR,spt_GOP_PROPERTY_TRANSCOLOR,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_PROGRESSIVE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_PROGRESSIVE,spt_GOP_PROPERTY_PROGRESSIVE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_ALPHAINVERSE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_ALPHAINVERSE,spt_GOP_PROPERTY_ALPHAINVERSE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_PREALPHAMODE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_PREALPHAMODE,spt_GOP_PROPERTY_PREALPHAMODE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_FIELD_INVERSE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_FIELD_INVERSE,spt_GOP_PROPERTY_FIELD_INVERSE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_HSCALE_RATIO:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_HSCALE_RATIO,spt_GOP_PROPERTY_HSCALE_RATIO,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_VSCALE_RATIO:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_VSCALE_RATIO,spt_GOP_PROPERTY_VSCALE_RATIO,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_OUTPUT_TIMING:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_OUTPUT_TIMING,spt_GOP_PROPERTY_OUTPUT_TIMING,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_PIXELBASE_ENABLE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_PIXELBASE_ENABLE,spt_GOP_PROPERTY_PIXELBASE_ENABLE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_CLK:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_CLK,spt_GOP_PROPERTY_CLK,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_FORCE_WRITE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_FORCE_WRITE,spt_GOP_PROPERTY_FORCE_WRITE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_BANK_FORCE_WRITE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_BANK_FORCE_WRITE,spt_GOP_PROPERTY_BANK_FORCE_WRITE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_3D_LR_EXCHANGE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_3D_LR_EXCHANGE,spt_GOP_PROPERTY_3D_LR_EXCHANGE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_VE_OSD:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_VE_OSD,spt_GOP_PROPERTY_VE_OSD,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_OUTPUT_LAYER_SWITCH:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_OUTPUT_LAYER_SWITCH,spt_GOP_PROPERTY_OUTPUT_LAYER_SWITCH,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_SWAP_OVERLAP_WIN:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_SWAP_OVERLAP_WIN,spt_GOP_PROPERTY_SWAP_OVERLAP_WIN,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_BW_STRENGTH:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_BW_STRENGTH,spt_GOP_PROPERTY_BW_STRENGTH,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_LB_COUPLE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_LB_COUPLE,spt_GOP_PROPERTY_LB_COUPLE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_YUV:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_YUV,spt_GOP_PROPERTY_YUV,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_REG_UPDATED:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_REG_UPDATED,spt_GOP_PROPERTY_REG_UPDATED,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_RELATIVE_WIN_PRIO:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_RELATIVE_WIN_PRIO,spt_GOP_PROPERTY_RELATIVE_WIN_PRIO,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_RESOURCE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_RESOURCE,spt_GOP_PROPERTY_RESOURCE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_MAXFBNUM:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_MAXFBNUM,spt_GOP_PROPERTY_MAXFBNUM,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_MULTI_ALPHA_ENABLE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_MULTI_ALPHA_ENABLE,spt_GOP_PROPERTY_MULTI_ALPHA_ENABLE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_GWIN_TLB_ENABLE:
                        //u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_TLB_ENABLE,spt_GOP_PROPERTY_TLB_ENABLE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_AFBC_CORE_RESET:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_AFBC_CORE_RESET,spt_GOP_PROPERTY_AFBC_CORE_RESET,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_AFBC_CORE_ENABLE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PROPERTY_AFBC_CORE_EN,spt_GOP_PROPERTY_AFBC_CORE_EN,buffer_arg,sizeof(buffer_arg));
                        break;
                     case E_GOP_NUM_IS_INIT:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_INIT_pInfo_noparameter,spt_GOP_INIT_pInfo_noparameter,buffer_arg,sizeof(buffer_arg));
                        break;
                }
                break;
            }
        case MAPI_CMD_GOP_SET_DST:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_SETDST, spt_GOP_SETDST,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_GET_DST:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GETDST, spt_GOP_GETDST,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_SET_MUX:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_SETMUX, spt_GOP_SETMUX,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_SET_LAYER:
        case MAPI_CMD_GOP_GET_LAYER:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_LAYER, spt_GOP_LAYER,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_SET_MIRROR:
        case MAPI_CMD_GOP_GET_MIRROR:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MIRROR, spt_GOP_MIRROR,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_GET_STATUS:
            {
                GOP_GET_STATUS_PARAM ptr;
                if(copy_from_user(&ptr, (GOP_GET_STATUS_PARAM __user *)pArgs, sizeof(GOP_GET_STATUS_PARAM)))
                {
                    return UTOPIA_STATUS_FAIL;
                }
                switch(ptr.en_status)
                {
                    case E_GOP_STATUS_CURRENT_GOP:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_STATUS_CURRENT_GOP,spt_GOP_STATUS_CURRENT_GOP,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_STATUS_CURRENT_GWIN:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_STATUS_CURRENT_GWIN,spt_GOP_STATUS_CURRENT_GWIN,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_STATUS_CURRENT_FBID:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_STATUS_CURRENT_FBID,spt_GOP_STATUS_CURRENT_FBID,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_STATUS_GOP_MAXNUM:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_STATUS_GOP_MAXNUM,spt_GOP_STATUS_GOP_MAXNUM,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_STATUS_GWIN_MAXNUM:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_STATUS_GWIN_MAXNUM,spt_GOP_STATUS_GWIN_MAXNUM,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_STATUS_GWIN_TOTALNUM:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_STATUS_GWIN_TOTALNUM,spt_GOP_STATUS_GWIN_TOTALNUM,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_STATUS_INIT:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_STATUS_INIT,spt_GOP_STATUS_INIT,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_STATUS_VERSION:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_STATUS_VERSION,spt_GOP_STATUS_VERSION,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_STATUS_MUX:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_STATUS_MUX,spt_GOP_STATUS_MUX,buffer_arg,sizeof(buffer_arg));
                        break;
                }
                break;
            }
        //Stretch Win
        case MAPI_CMD_GOP_GWIN_SET_STRETCH:
        case MAPI_CMD_GOP_GWIN_GET_STRETCH:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_STRETCH, spt_GOP_STRETCH,buffer_arg,sizeof(buffer_arg));
            break;
        //GWIN info
        case MAPI_CMD_GOP_GWIN_SET_PROPERTY:
        case MAPI_CMD_GOP_GWIN_GET_PROPERTY:
            {
                GOP_GWIN_PROPERTY_PARAM ptr;
                if(copy_from_user(&ptr, (GOP_GWIN_PROPERTY_PARAM __user *)pArgs, sizeof(GOP_GWIN_PROPERTY_PARAM)))
                {
                    return UTOPIA_STATUS_FAIL;
                }
                switch(ptr.en_property)
                {
                    case E_GOP_GWIN_ENABLE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_PROPERTY_ENABLE,spt_GOP_GWIN_PROPERTY_ENABLE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_GWIN_BLENDING:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_PROPERTY_BLENDING,spt_GOP_GWIN_PROPERTY_BLENDING,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_GWIN_NEWAPLHA:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_PROPERTY_NEWAPLHA,spt_GOP_GWIN_PROPERTY_NEWAPLHA,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_GWIN_BLINK:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_PROPERTY_BLINK,spt_GOP_GWIN_PROPERTY_BLINK,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_GWIN_SHARE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_PROPERTY_SHARE,spt_GOP_GWIN_PROPERTY_SHARE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_GWIN_SHARE_CNT:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_PROPERTY_SHARE_CNT,spt_GOP_GWIN_PROPERTY_SHARE_CNT,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_GWIN_SWITCH_2_GWIN:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_PROPERTY_SWITCH_2_GWIN,spt_GOP_GWIN_PROPERTY_SWITCH_2_GWIN,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_GWIN_3D_MODE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_PROPERTY_3D_MODE,spt_GOP_GWIN_PROPERTY_3D_MODE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_GWIN_EXIST:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_PROPERTY_EXIST,spt_GOP_GWIN_PROPERTY_EXIST,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_GWIN_FREE_ID:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_PROPERTY_FREE_ID,spt_GOP_GWIN_PROPERTY_FREE_ID,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_GWIN_GET_FB:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_PROPERTY_GET_FB,spt_GOP_GWIN_PROPERTY_GET_FB,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_GWIN_GET_GOP:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_PROPERTY_GET_GOP,spt_GOP_GWIN_PROPERTY_GET_GOP,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_GWIN_GPUTILE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_PROPERTY_GOPTILE,spt_GOP_GWIN_PROPERTY_GOPTILE,buffer_arg,sizeof(buffer_arg));
                        break;
                }
                break;
            }
        case MAPI_CMD_GOP_GWIN_MAPFB2WIN:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_MAPFBINFO,spt_GOP_GWIN_MAPFBINFO,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_GWIN_SET_WININFO:
        case MAPI_CMD_GOP_GWIN_GET_WININFO:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_SETWININFO,spt_GOP_GWIN_SETWININFO,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_GWIN_SETDISPLAY:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_DISPLAY,spt_GOP_GWIN_DISPLAY,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_GWIN_DESTROY:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_DESTROY,spt_GOP_GWIN_DESTROY,buffer_arg,sizeof(buffer_arg));
            break;
        //GFLIP
        case MAPI_CMD_GOP_GFLIP_CLEARQUEUE:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_CLEARQUEUE,spt_GOP_GWIN_CLEARQUEUE,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_GFLIP_SWITCHGWIN:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_GFLIP_SWITCH_GWIN, spt_GOP_GWIN_GFLIP_SWITCH_GWIN,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_GFLIP_SWITCHMULTIGWIN:
        #if 1
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_GFLIP_SWITCH_MULTI_GWIN,spt_GOP_GWIN_GFLIP_SWITCH_MULTI_GWIN,buffer_arg,sizeof(buffer_arg));
        #else
            //u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_GWIN_GFLIP_SWITCH_MULTI_GWIN,spt_GOP_GWIN_GFLIP_SWITCH_MULTI_GWIN,buffer_arg,sizeof(buffer_arg));
            MS_U8 i=0;
            GOP_GWIN_GFLIP_SWITCH_MULTI_GWIN_PARAM Str;
            GOP_GWIN_FLIP_MULTI_WIN_INFO Str_A0;
            GOP_GWIN_FLIP_WIN_INFO Str_A0B0[GOP_MULTIINFO_NUM];
            MS_U32 Str_A0B0CO[GOP_MULTIINFO_NUM];

            PGOP_GWIN_GFLIP_SWITCH_MULTI_GWIN_PARAM Usr=NULL;
            PGOP_GWIN_FLIP_MULTI_WIN_INFO Usr_A0=NULL;
            GOP_GWIN_FLIP_WIN_INFO* Usr_A0B0[GOP_MULTIINFO_NUM];
            MS_U32* Usr_A0B0CO=NULL;

            Usr = (PGOP_GWIN_GFLIP_SWITCH_MULTI_GWIN_PARAM)pArgs;
            Usr_A0 = (PGOP_GWIN_FLIP_MULTI_WIN_INFO)Usr->pMultiFlipInfo;
            Usr_A0B0[0] = (GOP_GWIN_FLIP_WIN_INFO*)&Usr_A0->FlipInfo;

            if(copy_from_user(&Str, Usr, sizeof(GOP_GWIN_GFLIP_SWITCH_MULTI_GWIN_PARAM)))
            {
                return UTOPIA_STATUS_FAIL;
            }
            Str.pMultiFlipInfo = (MS_U32*)&Str_A0;
            if(copy_from_user(&Str_A0, Usr_A0, sizeof(GOP_GWIN_FLIP_MULTI_WIN_INFO)))
            {
                return UTOPIA_STATUS_FAIL;
            }
            if(copy_from_user(&Str_A0B0[0], Usr_A0B0, sizeof(GOP_GWIN_FLIP_WIN_INFO)*Usr_A0->u8InfoCnt))
            {
                return UTOPIA_STATUS_FAIL;
            }

            for(i=0; i<Usr_A0->u8InfoCnt; i++)
            {
                Usr_A0B0CO = (MS_U32*)Usr_A0B0[i]->pQueueCnt;

                Str_A0.FlipInfo[i] = Str_A0B0[i];
                Str_A0B0[i].pQueueCnt =(MS_U32*)&Str_A0B0CO;
                if(copy_from_user(&Str_A0B0CO[i], Usr_A0B0CO, sizeof(MS_U32)))
                {
                    return UTOPIA_STATUS_FAIL;
                }
            }
            u32Ret=UtopiaIoctl(pInstanceTmp, u32Cmd, (void*)&Str);
        }
        #endif
            break;

        case MAPI_CMD_GOP_GFLIP_RESTORE_VSYNC_LMT:
            u32Ret= UtopiaIoctl(pInstanceTmp,u32Cmd,pArgs);
            break;
        //PINPON
        case MAPI_CMD_GOP_SET_PINPON:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_SET_PINPON_PINPON,spt_GOP_SET_PINPON_PINPON,buffer_arg,sizeof(buffer_arg));
            break;
        //FB Info
        case MAPI_CMD_GOP_FB_CREATE:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_CREATE_BUFFER,spt_GOP_CREATE_BUFFER,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_FB_DESTROY:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DELETE_BUFFER,spt_GOP_DELETE_BUFFER,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_FB_GETINFO:
        case MAPI_CMD_GOP_FB_SETINFO:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_FB_INFO,spt_GOP_FB_INFO,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_FB_SET_PROPERTY:
        case MAPI_CMD_GOP_FB_GET_PROPERTY:
            {
                GOP_FB_PROPERTY_PARAM ptr;
                if(copy_from_user(&ptr, (GOP_FB_PROPERTY_PARAM __user *)pArgs, sizeof(GOP_FB_PROPERTY_PARAM)))
                {
                    return UTOPIA_STATUS_FAIL;
                }
                switch(ptr.en_property)
                {
                    case E_GOP_FB_POOLID:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_FB_PROPERTY_POOLID,spt_GOP_FB_PROPERTY_POOLID,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_FB_EXIST:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_FB_PROPERTY_EXIST,spt_GOP_FB_PROPERTY_EXIST,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_FB_OBTAIN:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_FB_PROPERTY_OBTAIN,spt_GOP_FB_PROPERTY_OBTAIN,buffer_arg,sizeof(buffer_arg));
                        break;
                }
                break;
            }
        //palette
        case MAPI_CMD_GOP_PALETTE_SET_CONFIG:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PALETTE_CONFIG,spt_GOP_PALETTE_CONFIG,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_PALETTE_SET_ENTRY:
            {
#ifdef CONFIG_COMPAT
if(is_compat_task()==1)
{
            compat_uint_t i;
            compat_uptr_t p;
            int err= 0;

            GOP_PALETTE_SET_PARAM_32 __user *data32;
            GOP_PALETTE_SET_PARAM __user *data;
            data = compat_alloc_user_space(sizeof(*data));
            if (data == NULL)
                return -EFAULT;
            data32 = compat_ptr(pArgs);
            err = get_user(i, &data32->type);
            err |= put_user(i, &data->type);
            err |= get_user(p, &data32->pClut);
            err |= put_user(compat_ptr(p), &data->pClut);
            err |= get_user(i, &data32->u32Size);
            err |= put_user(i, &data->u32Size);
            if (err)
                return err;

            GOP_PALETTE_ENTRY_32 __user *data32_Pale;
            GOP_PALETTE_ENTRY __user *data_Pale;
            data_Pale = compat_alloc_user_space(sizeof(*data_Pale));
            if (data_Pale == NULL)
                return -EFAULT;
            data32_Pale = compat_ptr(data32->pClut);
            data->pClut= &data_Pale;
            err = get_user(i, &data32_Pale->gop_idx);
            err |= put_user(i, &data_Pale->gop_idx);
            err |= get_user(i, &data32_Pale->start);
            err |= put_user(i, &data_Pale->start);
            err |= get_user(i, &data32_Pale->end);
            err |= put_user(i, &data_Pale->end);
            err |= get_user(p, &data32_Pale->pClut);
            err |= put_user(compat_ptr(p), &data_Pale->pClut);
            err |= get_user(i, &data32_Pale->palType);
            err |= put_user(i, &data_Pale->palType);
            err |= get_user(i, &data32_Pale->palSrc);
            err |= put_user(i, &data_Pale->palSrc);
			if (err)
				return err;
            UADP_SPT_BGN(&spt_GOP_PALETTE_SET_ENTRY_A0B0[0],sizeof(GOP_PaletteEntry)*(data32_Pale->end-data32_Pale->start+1));
            UADP_SPT_FIN(&spt_GOP_PALETTE_SET_ENTRY_A0B0[1]);
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PALETTE_SET_ENTRY,spt_GOP_PALETTE_SET_ENTRY,buffer_arg,sizeof(buffer_arg));
}
else
#endif
{
            GOP_PALETTE_SET_PARAM Str;
            GOP_PALETTE_ENTRY Str_A0;
            //MS_U32 Str_A0B0[256]={0};
            MS_U32 *Str_A0B0 = NULL;

            PGOP_PALETTE_SET_PARAM Usr=NULL;
            GOP_PALETTE_ENTRY* Usr_A0=NULL;
            MS_U32* Usr_A0B0=NULL;

            Usr=(PGOP_PALETTE_SET_PARAM)pArgs;
            Usr_A0 = (GOP_PALETTE_ENTRY*)Usr->pClut;
            Usr_A0B0 = (MS_U32*)Usr_A0->pClut;

            if(copy_from_user(&Str, Usr, sizeof(GOP_PALETTE_SET_PARAM)))
            {
                return UTOPIA_STATUS_FAIL;
            }
            Str.pClut = (MS_U32*)&Str_A0;
            if(copy_from_user(&Str_A0, Usr_A0, sizeof(GOP_PALETTE_ENTRY)))
            {
                return UTOPIA_STATUS_FAIL;
            }
            Str_A0B0 = malloc(sizeof(MS_U32) * 256);
            if(Str_A0B0 != NULL)
            {
                memset(Str_A0B0, 0x0, sizeof(MS_U32) * 256);
            }
            else
            {
                printk("MAPI_CMD_GOP_PALETTE_SET_ENTRY, malloc fail\n");
                return UTOPIA_STATUS_FAIL;
            }
            Str_A0.pClut = (MS_U32*)Str_A0B0;
            if(copy_from_user(Str_A0B0, Usr_A0B0, sizeof(MS_U32)*(Usr_A0->end-Usr_A0->start+1)))
            {
                if(Str_A0B0 != NULL)
                {
                    free(Str_A0B0);
                    Str_A0B0 = NULL;
                }
                return UTOPIA_STATUS_FAIL;
            }
            u32Ret=UtopiaIoctl(pInstanceTmp, u32Cmd, (void*)&Str);
            if(Str_A0B0 != NULL)
            {
                free(Str_A0B0);
                Str_A0B0 = NULL;
            }
}
            }
            break;
        case MAPI_CMD_GOP_PALETTE_GET_ENTRY:
            {

#ifdef CONFIG_COMPAT
if(is_compat_task()==1)
{
             compat_uint_t i;
             compat_uptr_t p;
             int err= 0;

             GOP_PALETTE_SET_PARAM_32 __user *data32;
             GOP_PALETTE_SET_PARAM __user *data;
             data = compat_alloc_user_space(sizeof(*data));
             if (data == NULL)
                 return -EFAULT;
             data32 = compat_ptr(pArgs);
             err = get_user(i, &data32->type);
             err |= put_user(i, &data->type);
             err |= get_user(p, &data32->pClut);
             err |= put_user(compat_ptr(p), &data->pClut);
             err |= get_user(i, &data32->u32Size);
             err |= put_user(i, &data->u32Size);
             if (err)
                 return err;

             GOP_PALETTE_ENTRY_32 __user *data32_Pale;
             GOP_PALETTE_ENTRY __user *data_Pale;
             data_Pale = compat_alloc_user_space(sizeof(*data_Pale));
             if (data_Pale == NULL)
                 return -EFAULT;
             data32_Pale = compat_ptr(data32->pClut);
             data->pClut= &data_Pale;
             err = get_user(i, &data32_Pale->gop_idx);
             err |= put_user(i, &data_Pale->gop_idx);
             err |= get_user(i, &data32_Pale->start);
             err |= put_user(i, &data_Pale->start);
             err |= get_user(i, &data32_Pale->end);
             err |= put_user(i, &data_Pale->end);
             err |= get_user(p, &data32_Pale->pClut);
             err |= put_user(compat_ptr(p), &data_Pale->pClut);
             err |= get_user(i, &data32_Pale->palType);
             err |= put_user(i, &data_Pale->palType);
             err |= get_user(i, &data32_Pale->palSrc);
             err |= put_user(i, &data_Pale->palSrc);
             if (err)
                 return err;
             UADP_SPT_BGN(&spt_GOP_PALETTE_SET_ENTRY_A0B0[0],sizeof(GOP_PaletteEntry)*(data32_Pale->end-data32_Pale->start+1));
             UADP_SPT_FIN(&spt_GOP_PALETTE_SET_ENTRY_A0B0[1]);
             u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_PALETTE_SET_ENTRY ,spt_GOP_PALETTE_SET_ENTRY,buffer_arg,sizeof(buffer_arg));
}
else
#endif
{
            GOP_PALETTE_SET_PARAM Str;
            GOP_PALETTE_ENTRY Str_A0;
            //MS_U32 Str_A0B0[256]={0};
            MS_U32 *Str_A0B0 = NULL;

            PGOP_PALETTE_SET_PARAM Usr=NULL;
            GOP_PALETTE_ENTRY* Usr_A0=NULL;
            MS_U32* Usr_A0B0=NULL;

            Usr=(PGOP_PALETTE_SET_PARAM)pArgs;
            Usr_A0 = (GOP_PALETTE_ENTRY*)Usr->pClut;
            Usr_A0B0 = (MS_U32*)Usr_A0->pClut;

            Str.pClut = (MS_U32*)&Str_A0;
            //Str_A0.pClut = (MS_U32*)Str_A0B0;

            if(copy_from_user(&Str, Usr, sizeof(GOP_PALETTE_SET_PARAM)))
            {
                return UTOPIA_STATUS_FAIL;
            }

            Str_A0B0 = malloc(sizeof(MS_U32) * 256);
            if(Str_A0B0 != NULL)
            {
                memset(Str_A0B0, 0x0, sizeof(MS_U32) * 256);
            }
            else
            {
                printk("MAPI_CMD_GOP_PALETTE_SET_ENTRY, malloc fail\n");
                return UTOPIA_STATUS_FAIL;
            }
            Str_A0.pClut = (MS_U32*)Str_A0B0;

            if(copy_from_user(&Str_A0, Usr_A0, sizeof(GOP_PALETTE_ENTRY)))
            {
                if(Str_A0B0 != NULL)
                {
                    free(Str_A0B0);
                    Str_A0B0 = NULL;
                }
                return UTOPIA_STATUS_FAIL;
            }

            u32Ret=UtopiaIoctl(pInstanceTmp, u32Cmd, (void*)&Str);
            if(copy_to_user(Usr, &Str, sizeof(GOP_PALETTE_SET_PARAM)))
            {
                return UTOPIA_STATUS_FAIL;
            }
            if(copy_to_user(Usr_A0, &Str_A0, sizeof(GOP_PALETTE_ENTRY)))
            {
                return UTOPIA_STATUS_FAIL;
            }

            if(copy_to_user(Usr_A0B0, Str_A0B0, sizeof(MS_U32)*(Usr_A0->end-Usr_A0->start+1)))
            {
                return UTOPIA_STATUS_FAIL;
            }
            if(Str_A0B0 != NULL)
            {
                free(Str_A0B0);
                Str_A0B0 = NULL;
            }
            break;
}
            }
        //Scroll
        case MAPI_CMD_GOP_SET_SCROLL:
            {
                GOP_SCROLL_PARAM ptr;
                if(copy_from_user(&ptr, (GOP_SCROLL_PARAM __user *)pArgs, sizeof(GOP_SCROLL_PARAM)))
                {
                    return UTOPIA_STATUS_FAIL;
                }
                switch(ptr.scroll_type)
                {
                    case E_GOP_SCROLL_CONFIG:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_SCROLL_CONFIG, NULL,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_SCROLL_RATE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_SCROLL_RATE, NULL,buffer_arg,sizeof(buffer_arg));
                        break;
                }
                break;
            }
        case MAPI_CMD_GOP_GWIN_SET_FADE:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_SET_FADE_CONFIG,spt_GOP_SET_FADE_CONFIG,buffer_arg,sizeof(buffer_arg));
            break;
        //DWIN
        case MAPI_CMD_GOP_DWIN_INIT:
            u32Ret= UtopiaIoctl(pInstanceTmp,u32Cmd,pArgs);
            break;
        case MAPI_CMD_GOP_DWIN_CAPTURE:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_CAPTURE,spt_GOP_DWIN_CAPTURE,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_DWIN_INTR:
            {
                GOP_DWIN_INTR_STATUS_PARAM ptr;
                if(copy_from_user(&ptr, (GOP_DWIN_INTR_STATUS_PARAM __user *)pArgs, sizeof(GOP_DWIN_INTR_STATUS_PARAM)))
                {
                    return UTOPIA_STATUS_FAIL;
                }
                switch(ptr.intr_type)
                {
                    case E_GOP_DWIN_INTR_CONTROL:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_INTR_STATUS_CONTROL,spt_GOP_DWIN_INTR_STATUS_CONTROL,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_DWIN_INTR_GETINFO:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_INTR_STATUS_GETINFO,spt_GOP_DWIN_INTR_STATUS_GETINFO,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_DWIN_INTR_GETINFO_TIMEOUT:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_INTR_STATUS_GETINFO_TIMEOUT,spt_GOP_DWIN_INTR_STATUS_GETINFO_TIMEOUT,buffer_arg,sizeof(buffer_arg));
                        break;
                }
                break;
            }
        case MAPI_CMD_GOP_DWIN_SET_PROPERTY:
        case MAPI_CMD_GOP_DWIN_GET_PROPERTY:
            {
                GOP_DWIN_PROPERTY_PARAM ptr;
                if(copy_from_user(&ptr, (GOP_DWIN_PROPERTY_PARAM __user *)pArgs, sizeof(GOP_DWIN_PROPERTY_PARAM)))
                {
                    return UTOPIA_STATUS_FAIL;
                }
                switch(ptr.en_dwin_property)
                {
                    case E_GOP_DWIN_R2Y:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_PROPERTY_R2Y,spt_GOP_DWIN_PROPERTY_R2Y,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_DWIN_UV_SWAP:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_PROPERTY_UV_SWAP,spt_GOP_DWIN_PROPERTY_UV_SWAP,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_DWIN_UV_SAMPLE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_PROPERTY_UV_SAMPLE,spt_GOP_DWIN_PROPERTY_UV_SAMPLE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_DWIN_SOURCE_SCAN_TYPE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_PROPERTY_SOURCE_SCAN_TYPE,spt_GOP_DWIN_PROPERTY_SOURCE_SCAN_TYPE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_DWIN_ALPHA_VALUE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_PROPERTY_ALPHA_VALUE,spt_GOP_DWIN_PROPERTY_ALPHA_VALUE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_DWIN_ALPHA_SOURCE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_PROPERTY_ALPHA_SOURCE,spt_GOP_DWIN_PROPERTY_ALPHA_SOURCE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_DWIN_ALPHA_INVERSE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_PROPERTY_ALPHA_INVERSE,spt_GOP_DWIN_PROPERTY_ALPHA_INVERSE,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_DWIN_SKIP_FRAME:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_PROPERTY_SKIP_FRAME,spt_GOP_DWIN_PROPERTY_SKIP_FRAME,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_DWIN_PINPON:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_PROPERTY_PINPON,spt_GOP_DWIN_PROPERTY_PINPON,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_DWIN_INTERRUP_INFO:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_PROPERTY_INTERRUP_INFO,spt_GOP_DWIN_PROPERTY_INTERRUP_INFO,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_DWIN_CAPTURE_INFO:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_DWIN_PROPERTY_CAPTURE_INFO,spt_GOP_DWIN_PROPERTY_CAPTURE_INFO,buffer_arg,sizeof(buffer_arg));
                        break;
                }
                break;
            }
        //MIXER
        case MAPI_CMD_GOP_MIXER_SET_PROPERTY:
        case MAPI_CMD_GOP_MIXER_GET_PROPERTY:
            {
                GOP_MIXER_PROPERTY_PARAM ptr;
                if(copy_from_user(&ptr, (GOP_MIXER_PROPERTY_PARAM __user *)pArgs, sizeof(GOP_MIXER_PROPERTY_PARAM)))
                {
                    return UTOPIA_STATUS_FAIL;
                }
                switch(ptr.en_mixer_property)
                {
                    case E_GOP_MIXER_OUTPUT_TIMING:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MIXER_PROPERTY_OUTPUT_TIMING,spt_GOP_MIXER_PROPERTY_OUTPUT_TIMING,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_MIXER_TO_OP_OUTPUT_TIMING:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MIXER_PROPERTY_TO_OP_OUTPUT_TIMING,spt_GOP_MIXER_PROPERTY_TO_OP_OUTPUT_TIMING,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_MIXER_V_FILTER:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MIXER_PROPERTY_V_FILTER,spt_GOP_MIXER_PROPERTY_V_FILTER,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_MIXER_OLD_BLENDING_MODE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MIXER_PROPERTY_OLD_BLENDING_MODE,spt_GOP_MIXER_PROPERTY_OLD_BLENDING_MODE,buffer_arg,sizeof(buffer_arg));
                        break;
                }
                break;
            }
            break;
        //VE
        case MAPI_CMD_GOP_VE_SET_PROPERTY:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_VE_PROPERTY_OUTPUT_TIMING,spt_GOP_VE_PROPERTY_OUTPUT_TIMING,buffer_arg,sizeof(buffer_arg));
            break;
        //MISC
        case MAPI_CMD_GOP_UPDATE:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_UPDATE,spt_GOP_UPDATE,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_REGISTER_CB:
            {
                GOP_REGISTER_CB_PARAM ptr;
                if(copy_from_user(&ptr, (GOP_REGISTER_CB_PARAM __user *)pArgs, sizeof(GOP_REGISTER_CB_PARAM)))
                {
                    return UTOPIA_STATUS_FAIL;
                }
                switch(ptr.cb_type)
                {
                    case GOP_CB_XC_INTERLACE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_CB_INTERLACE,NULL,buffer_arg,sizeof(buffer_arg));
                        break;
                    case GOP_CB_XC_PANEL_HSTART:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_CB_HSTART,NULL,buffer_arg,sizeof(buffer_arg));
                        break;
                }
            break;
            }
        case MAPI_CMD_GOP_TESTPATTERN:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_TESTPATTERN,NULL,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_SELECTION:
            {
                GOP_SELECTION_PROPERTY_PARAM ptr;
                if(copy_from_user(&ptr, pArgs, sizeof(GOP_SELECTION_PROPERTY_PARAM)))
                {
                    return UTOPIA_STATUS_FAIL;
                }
                switch(ptr.sel_type)
                {
                    case EN_GOP_SEL_GOP:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_SELECTION_SELGOP, NULL,buffer_arg,sizeof(buffer_arg));
                        break;
                    case EN_GOP_SEL_GWIN:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_SELECTION_SELGWIN, NULL,buffer_arg,sizeof(buffer_arg));
                        break;
                    case EN_GOP_SEL_FB:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_SELECTION_SELFB, spt_GOP_SELECTION_SELFB,buffer_arg,sizeof(buffer_arg));
                        break;
                    default:
                        break;
                }
            break;
            }
        case MAPI_CMD_GOP_MUTEX:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MUTEX,spt_GOP_MUTEX,buffer_arg,sizeof(buffer_arg));
            break;
        case MAPI_CMD_GOP_MISC:
            {
                GOP_MISC_PARAM ptr;
                if(copy_from_user(&ptr, (GOP_MISC_PARAM __user *)pArgs, sizeof(GOP_MISC_PARAM)))
                {
                    return UTOPIA_STATUS_FAIL;
                }
                switch(ptr.misc_type)
                {
                    case E_GOP_MISC_ENABLE_T3D:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MISC_ENABLE_T3D,spt_GOP_MISC_ENABLE_T3D,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_MISC_SET_CAPTURE_CLK:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MISC_SET_CAPTURE_CLK,spt_GOP_MISC_SET_CAPTURE_CLK,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_MISC_POWER_OFF:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MISC_POWER_OFF,spt_GOP_MISC_POWER_OFF,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_MISC_POWER_ON:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MISC_POWER_ON,spt_GOP_MISC_POWER_ON,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_MISC_GET_RT_STATUS:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MISC_GET_RT_STATUS,spt_GOP_MISC_GET_RT_STATUS,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_MISC_GET_INFO:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MISC_GET_INFO,spt_GOP_MISC_GET_INFO,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_MISC_AT_EXIT:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MISC_AT_EXIT,spt_GOP_MISC_AT_EXIT,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_MISC_OC_FB_INFO:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MISC_OC_FB_INFO,spt_GOP_MISC_OC_FB_INFO,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_MISC_TESTPATTERN_ALPHA:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MISC_TESTPATTERN_ALPHA,spt_GOP_MISC_TESTPATTERN_ALPHA,buffer_arg,sizeof(buffer_arg));
                        break;
                    case E_GOP_MISC_DELETE_GWINSIZE:
                        u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_MISC_DELETE_GWINSIZE,NULL ,buffer_arg,sizeof(buffer_arg));
                        break;
                }
                break;
            }
        case MAPI_CMD_GOP_RESETPOOL:
            u32Ret= UtopiaIoctl(pInstanceTmp,u32Cmd,pArgs);
            break;
        case MAPI_CMD_GOP_POWERSTATE:
            u32Ret=UADPBypassIoctl(pInstanceTmp,u32Cmd,pArgs,spt_GOP_POWERSTATE_PARAM,spt_GOP_POWERSTATE_PARAM,buffer_arg,sizeof(buffer_arg));
            break;
        default:
            break;
    }
    return u32Ret;
}