/* -*- pse-c -*- *----------------------------------------------------------------------------- * Filename: iegd_escape.h * $Revision: 1.69 $ *----------------------------------------------------------------------------- * * Copyright (2002 - 2012) Intel Corporation All Rights Reserved. * The source code, information and material ("Material") contained herein is * owned by Intel Corporation or its suppliers or licensors, and title to such * Material remains with Intel Corporation or its suppliers or licensors. The * Material contains proprietary information of Intel or its suppliers and * licensors. The Material is protected by worldwide copyright laws and treaty * provisions. No part of the Material may be used, copied, reproduced, modified, * published, uploaded, posted, transmitted, distributed or disclosed in any way * without Intel's prior express written permission. No license under any patent, * copyright or other intellectual property rights in the Material is granted to * or conferred upon you, either expressly, by implication, inducement, estoppel * or otherwise. Any license under such intellectual property rights must be * express and approved by Intel in writing. * *----------------------------------------------------------------------------- * Description: * This file defines the API for communication with the IEGD driver's * proprietary escape interfaces. These interfaces provide a consistent * mechanism to control features of IEGD across multiple operating systems * and implementations. *----------------------------------------------------------------------------- * Authors: * *----------------------------------------------------------------------------- */ #ifndef _IEGD_ESCAPE_H #define _IEGD_ESCAPE_H #define MAX_NAME_LEN 256 #define INTEL_ESCAPE_NOT_SUPPORTED -1 #define INTEL_ESCAPE_SUCCESS 0 #define INTEL_ESCAPE_ERROR 1 #define INTEL_ESCAPE_STATUS_NOERROR 0 #define INTEL_ESCAPE_NO_REPLY 0x01000 /* don't send reply */ #define INTEL_ESCAPE_GET_CURRENT_MODE 0x20000 #define INTEL_ESCAPE_GET_NUM_MODES 0x20001 #define INTEL_ESCAPE_GET_AVAIL_MODES 0x20002 #define INTEL_ESCAPE_ENABLE_PORT 0x20005 #define INTEL_ESCAPE_MULTI_DISPLAY 0x20006 /* deprecated */ #define INTEL_ESCAPE_GET_NUM_PD_ATTRIBUTES 0x20007 #define INTEL_ESCAPE_GET_AVAIL_PD_ATTRIBUTES 0x20008 #define INTEL_ESCAPE_SET_PD_ATTRIBUTES 0x20009 #define INTEL_ESCAPE_I2C_CONFIG 0x2000A /* Not support on X */ #define INTEL_ESCAPE_I2C_ACCESS 0x2000B /* Not support on X */ #define INTEL_ESCAPE_GET_NUM_DISPLAYS 0x2000C /* deprecated */ #define INTEL_ESCAPE_ENUM_DISPLAYS 0x2000D /* deprecated */ #define INTEL_ESCAPE_SET_ROTATION_FLIP 0x2000E #define INTEL_ESCAPE_GET_ROTATION_FLIP 0x2000F #define INTEL_ESCAPE_GET_DRIVER_INFO 0x20012 #define INTEL_ESCAPE_GET_PORT_INFO 0x20014 #define INTEL_ESCAPE_GET_CURRENT_DC 0x20015 #define INTEL_ESCAPE_GET_DC_LIST 0x20016 #define INTEL_ESCAPE_SET_DC 0x20017 #define INTEL_ESCAPE_GET_NUM_DC 0x20018 #define INTEL_ESCAPE_GET_OVL_COLOR_PARAMS 0x20019 #define INTEL_ESCAPE_SET_OVL_COLOR_PARAMS 0x2001A #define INTEL_ESCAPE_NOOP 0x20020 #define INTEL_ESCAPE_NOOP_DRAWABLE (0x20021 | INTEL_ESCAPE_NO_REPLY) #define INTEL_ESCAPE_GET_DEBUG 0x20022 #define INTEL_ESCAPE_SET_DEBUG 0x20023 #define INTEL_ESCAPE_GET_EDID_INFO 0x20024 /* Num same as Windows */ #define INTEL_ESCAPE_QUERY_COMPOSITE 0x20025 #define INTEL_ESCAPE_QUERY_GOLDEN_HTOTAL 0x20026 /* X driver specific commands */ #define INTEL_ESCAPE_OVERLAY 0x20100 #define INTEL_ESCAPE_BLEND 0x20101 #define INTEL_ESCAPE_GRAB_OVERLAY 0x20102 #define INTEL_ESCAPE_RELEASE_OVERLAY 0x20103 /* Direct Rendering Related Commands */ #define INTEL_ESCAPE_BUFFER_INFO 0x20201 #define INTEL_ESCAPE_ALLOC_SURFACE 0x20202 #define INTEL_ESCAPE_FREE (0x20203 | INTEL_ESCAPE_NO_REPLY) #define INTEL_ESCAPE_SYNC 0x20204 #define INTEL_ESCAPE_ALLOC_REGION 0x20205 #define INTEL_ESCAPE_EXEC 0x20207 #define INTEL_ESCAPE_FILL 0x20208 #define INTEL_ESCAPE_BLIT 0x20209 #define INTEL_ESCAPE_BLIT_OFFSCREEN_TO_FB 0x2021A #define INTEL_ESCAPE_SURFACE_FROM_PIXMAP 0x2021B #define INTEL_ESCAPE_DRI 0x2021C #if defined(USE_PRIVATE_DPM_MEM) #define INTEL_ESCAPE_DOUBLE_MAP 0x2021D #endif /* CE specific commands */ /* FIXME - these maybe redundant?! see DRI escapes above! */ #define INTEL_ESCAPE_VIDEO_BUF_CREATE 0x20301 #define INTEL_ESCAPE_VIDEO_BUF_DESTROY 0x20302 #define INTEL_ESCAPE_VIDEO_BUF_EXECUTE 0x20303 #define INTEL_ESCAPE_CLIENTVIRT_TO_IEGDSURF 0x20304 #define INTEL_ESCAPE_ALLOC_CONTEXT 0x20305 #define INTEL_ESCAPE_FREE_CONTEXT 0x20306 #define INTEL_ESCAPE_GET_CLIENT_DD_SURF 0x20307 #define INTEL_ESCAPE_QUEUE_SWAP_DDFLIP_SURF 0x20308 /* WinSys specific commands */ #define INTEL_ESCAPE_WINSYS 0x20400 #define INTEL_ESCAPE_PRESENT 0x20401 /* Video Decode Design For Test commands */ #define INTEL_ESCAPE_VIDEO_CRC_START 0x20500 #define INTEL_ESCAPE_VIDEO_CRC_STOP 0x20501 #define INTEL_ESCAPE_GET_CRC 0x20502 #define INTEL_ESCAPE_GET_CRC_DEBUG_INFO 0x20503 #define INTEL_ESCAPE_GET_SURFACE_DATA 0x20510 /* Video frames per second command*/ #define INTEL_ESCAPE_GET_VID_RENDERING_INFO 0x20600 #define INTERLACE_FLAG 0x80000000 #ifdef CONFIG_DEBUG static __inline char *intel_esc_str(unsigned int esc) { switch (esc) { case INTEL_ESCAPE_GET_CURRENT_MODE: return "INTEL_ESCAPE_GET_CURRENT_MODE"; case INTEL_ESCAPE_GET_NUM_MODES: return "INTEL_ESCAPE_GET_NUM_MODES"; case INTEL_ESCAPE_GET_AVAIL_MODES: return "INTEL_ESCAPE_GET_AVAIL_MODES"; case INTEL_ESCAPE_ENABLE_PORT: return "INTEL_ESCAPE_ENABLE_PORT"; case INTEL_ESCAPE_MULTI_DISPLAY: return "INTEL_ESCAPE_MULTI_DISPLAY"; case INTEL_ESCAPE_GET_NUM_PD_ATTRIBUTES: return "INTEL_ESCAPE_GET_NUM_PD_ATTRIBUTES"; case INTEL_ESCAPE_GET_AVAIL_PD_ATTRIBUTES: return "INTEL_ESCAPE_GET_AVAIL_PD_ATTRIBUTES"; case INTEL_ESCAPE_SET_PD_ATTRIBUTES: return "INTEL_ESCAPE_SET_PD_ATTRIBUTES"; case INTEL_ESCAPE_I2C_CONFIG: return "INTEL_ESCAPE_I2C_CONFIG"; case INTEL_ESCAPE_I2C_ACCESS: return "INTEL_ESCAPE_I2C_ACCESS"; case INTEL_ESCAPE_GET_NUM_DISPLAYS: return "INTEL_ESCAPE_GET_NUM_DISPLAYS"; case INTEL_ESCAPE_ENUM_DISPLAYS: return "INTEL_ESCAPE_ENUM_DISPLAYS"; case INTEL_ESCAPE_SET_ROTATION_FLIP: return "INTEL_ESCAPE_SET_ROTATION_FLIP"; case INTEL_ESCAPE_GET_ROTATION_FLIP: return "INTEL_ESCAPE_GET_ROTATION_FLIP"; case INTEL_ESCAPE_GET_DRIVER_INFO: return "INTEL_ESCAPE_GET_DRIVER_INFO"; case INTEL_ESCAPE_GET_PORT_INFO: return "INTEL_ESCAPE_GET_PORT_INFO"; case INTEL_ESCAPE_GET_CURRENT_DC: return "INTEL_ESCAPE_GET_CURRENT_DC"; case INTEL_ESCAPE_GET_DC_LIST: return "INTEL_ESCAPE_GET_DC_LIST"; case INTEL_ESCAPE_SET_DC: return "INTEL_ESCAPE_SET_DC"; case INTEL_ESCAPE_GET_NUM_DC: return "INTEL_ESCAPE_GET_NUM_DC"; case INTEL_ESCAPE_GET_OVL_COLOR_PARAMS: return "INTEL_ESCAPE_GET_OVL_COLOR_PARAMS"; case INTEL_ESCAPE_SET_OVL_COLOR_PARAMS: return "INTEL_ESCAPE_SET_OVL_COLOR_PARAMS"; case INTEL_ESCAPE_NOOP: return "INTEL_ESCAPE_NOOP"; case INTEL_ESCAPE_NOOP_DRAWABLE: return "INTEL_ESCAPE_NOOP_DRAWABLE"; case INTEL_ESCAPE_GET_DEBUG: return "INTEL_ESCAPE_GET_DEBUG"; case INTEL_ESCAPE_SET_DEBUG: return "INTEL_ESCAPE_SET_DEBUG"; case INTEL_ESCAPE_GET_EDID_INFO: return "INTEL_ESCAPE_GET_EDID_INFO"; case INTEL_ESCAPE_OVERLAY: return "INTEL_ESCAPE_OVERLAY"; case INTEL_ESCAPE_BLEND: return "INTEL_ESCAPE_BLEND"; case INTEL_ESCAPE_BUFFER_INFO: return "INTEL_ESCAPE_BUFFER_INFO"; case INTEL_ESCAPE_ALLOC_SURFACE: return "INTEL_ESCAPE_ALLOC_SURFACE"; case INTEL_ESCAPE_FREE: return "INTEL_ESCAPE_FREE"; case INTEL_ESCAPE_SYNC: return "INTEL_ESCAPE_SYNC"; case INTEL_ESCAPE_ALLOC_REGION: return "INTEL_ESCAPE_ALLOC_REGION"; case INTEL_ESCAPE_EXEC: return "INTEL_ESCAPE_EXEC"; case INTEL_ESCAPE_FILL: return "INTEL_ESCAPE_FILL"; case INTEL_ESCAPE_BLIT: return "INTEL_ESCAPE_BLIT"; case INTEL_ESCAPE_BLIT_OFFSCREEN_TO_FB: return "INTEL_ESCAPE_BLIT_OFFSCREEN_TO_FB"; case INTEL_ESCAPE_SURFACE_FROM_PIXMAP: return "INTEL_ESCAPE_SURFACE_FROM_PIXMAP"; default: return "INTEL_ESCAPE Invalid"; } } #endif /* * The following typedefs define the input and output structures * that are passed between the driver and the client. These are * versioned, and must not be changed without incrementing the * protocal version number. */ typedef enum _mode_change_t { NO_MODE_SET_REQUIRED, MODE_SET_REQUIRED, } mode_change_t; typedef struct _iegd_esc_status { mode_change_t status; } iegd_esc_status_t; /* Port number input */ typedef struct _iegd_esc_port_in { unsigned long port_number; } iegd_esc_port_in_t; /* DC value input/output. On output an array of this type may be returned */ typedef struct _iegd_esc_dc { unsigned long dc; } iegd_esc_dc_t; /* For the functions that return a count it will return this */ typedef struct _iegd_esc_count { unsigned long count; } iegd_esc_count_t; /* Port attributes */ typedef struct _iegd_esc_attr { unsigned long id; unsigned long type; char name[32]; unsigned long flags; unsigned long default_value; unsigned long current_value; unsigned long _pad0; unsigned long _pad1; unsigned long _pad2; } iegd_esc_attr_t; /* Input to driver when setting a display mode */ typedef struct _iegd_esc_mode { unsigned long width; unsigned long height; unsigned long refresh; unsigned long depth; unsigned long port; /* needed to independently set clone's mode */ } iegd_esc_mode_t; /* Input to driver when querying mode table */ typedef struct _iegd_esc_mode_in { unsigned long port_number; unsigned long dc; } iegd_esc_mode_in_t; /* Input to driver to enable/disable a port */ typedef struct _iegd_esc_port_ctrl { int port; int enable; } iegd_esc_port_ctrl_t; /* Input to driver with a new attribute list */ typedef struct _iegd_esc_set_attr { unsigned long port_number; iegd_esc_attr_t attribute; } iegd_esc_set_attr_t; /* Input to driver with new DC, timings, and framebuffer config */ typedef struct _iegd_esc_set_dc { unsigned long dc; struct _timing { unsigned short width; unsigned short height; unsigned short refresh; unsigned long flags; /* Default: 0x0 */ } iegd_timings[2]; struct _fb { unsigned short width; unsigned short height; unsigned short bit_depth; } iegd_fb_info[2]; } iegd_esc_set_dc_t; /* Input to driver with surface information */ typedef struct _iegd_esc_surface_info { unsigned long screen; /* Screen number */ unsigned long surface_id; /* Surface to put */ unsigned long drawable_id; /* drawable */ unsigned short src_x; /* source X */ unsigned short src_y; /* source Y */ unsigned short src_w; /* source width */ unsigned short src_h; /* source height */ unsigned short dst_x; /* destination X */ unsigned short dst_y; /* destination Y */ unsigned short dst_w; /* destination width */ unsigned short dst_h; /* destination height */ unsigned long flags; /* surface flags */ } iegd_esc_surface_info_t; /* Input to driver with drawable info */ typedef struct _iegd_esc_drawable_info { unsigned long drawable_id; } iegd_esc_drawable_info_t; /* Input to driver with rotation/flip information */ typedef struct _iegd_esc_set_rotation_flip { unsigned long port_number; unsigned long rotation; /* rotation in degrees (0, 90, 180, 270) */ unsigned long flip; /* horizontal flip, zero or non-zero */ } iegd_esc_set_rotation_flip_t; /* Output from driver with rotation/flip information */ typedef struct _iegd_esc_get_rotation_flip { unsigned long rotation; /* rotation in degrees (0, 90, 180, 270) */ unsigned long flip; /* horizontal flip, zero or non-zero */ } iegd_esc_get_rotation_flip_t; /* Output from driver */ typedef struct _iegd_esc_driver_info { char name[MAX_NAME_LEN]; /* IEGD Driver Name */ char chipset[MAX_NAME_LEN]; /* Chipset name */ unsigned long major; /* Major version see personality.h */ unsigned long minor; /* Minor version see personality.h */ unsigned long build; /* Build number see personality.h */ char date[MAX_NAME_LEN]; /* Date of build */ unsigned short config_id; /* Current PCF config id */ unsigned long device_id; /* PCI Device ID */ unsigned long revision_id; /* PCI Revision ID */ unsigned long emgd_id_ver; /* Driver ID for GUI and miniport handshake */ } iegd_esc_driver_info_t; /* Output from driver with information about any port */ typedef struct _iegd_esc_port_info { unsigned long width; /* Current mode: screen width */ unsigned long height; /* Current mode: screen height */ unsigned long depth; /* Current mode: screen depth */ unsigned long refresh; /* Current mode: screen refresh */ unsigned long edid; /* Edid enable, 0 or 1 */ unsigned long enable; /* Port is enabled or disabled */ unsigned long timing_owner; /* Set if port owns timings */ char pd_name[MAX_NAME_LEN]; /* Port driver name see pd.h */ char user_alias[MAX_NAME_LEN]; /* User(via IAL reg/cfg file)port name */ unsigned long pd_version; /* Port driver version see pd.h */ unsigned long pd_type; /* Port driver type see pd.h */ unsigned long display_id; /* display currently associated with port*/ unsigned long flags; /* Display flag. Default: 0x0 */ } iegd_esc_port_info_t; /* Output from driver with current mode list */ typedef struct _iegd_esc_mode_list { unsigned short width; unsigned short height; unsigned short refresh; unsigned long dclk; /* in KHz */ unsigned short h_sync_start; unsigned short h_sync_length; unsigned short h_blank_start; unsigned short h_blank_length; unsigned short v_sync_start; unsigned short v_sync_length; unsigned short v_blank_start; unsigned short v_blank_length; unsigned short mode_number; unsigned long flags; /* Reserved for device dependant layer. Now used to store the HTotal Delta * For B0 Workaround. */ unsigned short reserved_dd; unsigned short reserved_dd_ext; } iegd_esc_mode_list_t; /* EDID info returned */ typedef struct _iegd_esc_edid_info { unsigned char edid[128]; } iegd_esc_edid_info_t; /* * Get/set debug info for drivers with debugging enabled. */ typedef struct _iegd_esc_debug_info { unsigned long hal_flags; unsigned long ial_flags; } iegd_esc_debug_info_t; #define GAMMA_FLAG 0x1 #define BRIGHTNESS_FLAG 0x2 #define CONTRAST_FLAG 0x4 #define SATURATION_FLAG 0x8 #define COLORKEY_FLAG 0x20 #define OVL_COLOR_FLAG 0x10 /* * the following escape structure is for dynamically changing the overlay * color attributes or frame buffer gamma correction * ** this backdoor is temporary and is for MPD only! ** */ typedef struct _iegd_esc_color_params { unsigned char flag; /* 0x1 = gamma, 0x2 = brightness */ /* 0x4 = contrast, 0x8 = saturation */ /*0x10 = Overlay colors; if not set for FB */ unsigned int gamma; unsigned int brightness; unsigned int contrast; unsigned int saturation; unsigned int colorkey; } iegd_esc_color_params_t; typedef struct _iegd_esc_i2c_config { char bus; /* I2C bus */ char dab; /* 7 bit device address byte */ unsigned long speed; /* i2c bus speed */ unsigned long enable; /* Internal use only */ } iegd_esc_i2c_config_t; #define INTEL_I2C_MODE_READ 1 #define INTEL_I2C_MODE_WRITE 2 typedef struct _iegd_esc_i2c_access { char addr; /* Register offset */ char data; /* Data to write (or read from device) */ unsigned long mode; /* read or write */ } iegd_esc_i2c_access_t; #define MULTI_TYPE_SINGLE 0x1 #define MULTI_TYPE_CLONE 0x2 #define MULTI_TYPE_TWIN 0x4 #define MULTI_TYPE_EXTENDED 0x8 /* * The buffer info escape details the front buffer information for * the requested screen. It also returns the sync slot used by that screen. * This escape is used with direct clients but can be called before the * direct connection is established. */ typedef struct _iegd_esc_buffer_info { unsigned int screen; } iegd_esc_buffer_info_t; typedef struct _iegd_esc_buffer_info_reply { unsigned int width; unsigned int height; unsigned int pitch; unsigned int pixel_format; unsigned int flags; unsigned int offset; unsigned int sync_slot; } iegd_esc_buffer_info_reply_t; /* * Structures needed for surface allocation and free from the internal * memory manager. */ typedef struct _iegd_esc_alloc_surface { #ifdef WINCE union { unsigned int drm_context; void * client_ctx; }; #else unsigned int drm_context; #endif unsigned int surface_type; unsigned int width; unsigned int height; unsigned int pixel_format; unsigned int flags; void *display_ptr; // unsigned int size // unsigned int offset } iegd_esc_alloc_surface_t; /* * For Normal surfaces only offset[0] is returned. * For MIPMAP surfaces up to 12 offsets are returned based on the number * of available levels of detail. * For Cubemap surfaces the Positive left surface offset is returned. * For Cubemap + Mipmap the offsets for each level of detail for the * positive left face are returned. The client can then calculate the * offsets for all LOD of all faces. * * Reply structure has to be consistence as client would expect variables * within structure to be consistent. Any modification would need to be * implemented across all surface reply structure. */ typedef struct _iegd_esc_alloc_surface_reply { #ifdef WINCE union { unsigned int drm_context; void * client_ctx; }; #else unsigned int drm_context; #endif int ret; unsigned int buffer_id; unsigned int width; unsigned int height; unsigned int pitch; unsigned int flags; unsigned int offset[12]; unsigned char * virt; } iegd_esc_alloc_surface_reply_t; /* * When allocating a volume surface the reply contains more offsets. */ typedef struct _iegd_esc_alloc_cube_surface_reply { #ifdef WINCE union { unsigned int drm_context; void * client_ctx; }; #else unsigned int drm_context; #endif int ret; unsigned int buffer_id; unsigned int width; unsigned int height; unsigned int pitch; unsigned int flags; unsigned int offset[6*12]; } iegd_esc_alloc_cube_surface_reply_t; /* * When allocating a volume surface the reply contains more offsets. */ typedef struct _iegd_esc_alloc_volume_surface_reply { #ifdef WINCE union { unsigned int drm_context; void * client_ctx; }; #else unsigned int drm_context; #endif int ret; unsigned int buffer_id; unsigned int width; unsigned int height; unsigned int pitch; unsigned int flags; unsigned int offset[511]; } iegd_esc_alloc_volume_surface_reply_t; typedef struct _iegd_esc_alloc_region { #ifdef WINCE union { unsigned int drm_context; void * client_ctx; }; #else unsigned int drm_context; #endif unsigned int region_type; unsigned int size; unsigned int flags; void *display_ptr; } iegd_esc_alloc_region_t; typedef struct _iegd_esc_alloc_region_reply { int ret; unsigned int buffer_id; unsigned int offset; unsigned int size; unsigned char * virt; } iegd_esc_alloc_region_reply_t; typedef struct _iegd_esc_free { #ifdef WINCE union { unsigned int drm_context; void * client_ctx; }; #else unsigned int drm_context; #endif unsigned int offset; unsigned char * virt; } iegd_esc_free_t; /* * Drawable is needed for exec to make sure that the correct * ring buffers and syncs are used. These may be different on a * per-display basis. */ typedef struct _iegd_esc_exec { unsigned int drm_context; unsigned int drawable; unsigned int size; /* data */ } iegd_esc_exec_t; typedef enum _iegd_surface_state { IEGD_SURFACE_STATE_GOOD = 0, IEGD_SURFACE_STATE_BAD, IEGD_SURFACE_STATE_FLIPPED, IEGD_SURFACE_STATE_PIXMAP } iegd_surface_state_t; typedef enum _iegd_sfp_success { IEGD_SFP_SUCCESS = 0, IEGD_SFP_FAILURE } iegd_sfp_success_state_t; typedef struct _iegd_esc_exec_reply { iegd_surface_state_t surface_state; unsigned int sync_id; } iegd_esc_exec_reply_t; typedef struct _iegd_esc_fill { unsigned int drm_context; unsigned int buffer_id; unsigned int x1; unsigned int y1; unsigned int x2; unsigned int y2; unsigned int color; } iegd_esc_fill_t; #define IEGD_REQUEST_FLIP 0x1 #define IEGD_REQUEST_ASYNC 0x2 #define IEGD_REQUEST_WAIT 0x4 #define IEGD_REQUEST_DEFAULT 0x8 typedef struct _iegd_esc_blit { #ifdef WINCE union { unsigned int drm_context; void * client_ctx; }; #else unsigned int drm_context; #endif unsigned int src_buffer_id; unsigned int dest_buffer_id; unsigned int drawable; unsigned int color; unsigned int src_x1; unsigned int src_y1; unsigned int src_x2; unsigned int src_y2; unsigned int dest_x1; unsigned int dest_y1; unsigned int dest_x2; unsigned int dest_y2; unsigned int flags; } iegd_esc_blit_t; typedef struct _iegd_esc_sfp { unsigned int drm_context; unsigned int glxdrawable; unsigned int buffer; } iegd_esc_sfp_t; typedef struct _iegd_esc_blit_reply { iegd_surface_state_t surface_state; unsigned long sync_id; } iegd_esc_blit_reply_t; typedef struct _iegd_esc_sfp_reply { iegd_sfp_success_state_t sfp_success; unsigned long pixel_format; unsigned long offset; /* Surface width & height */ unsigned int height; unsigned int width; unsigned int pitch; unsigned long flags; } iegd_esc_sfp_reply_t; #define IEGD_OVERLAY_COLORKEY 0x1 #define IEGD_OVERLAY_BLEND 0x2 #define IEGD_OVERLAY_SUBPICT 0x4 #define IEGD_OVERLAY_ALPHA 0x8 /* Global Alpha for Subpict */ #define IEGD_OVERLAY_CHROMA 0x10 /* Chroma for the Subpict */ #define IEGD_OVERLAY_SUBPICT_DIRTY 0x20 #define IEGD_OVERLAY_FIELD 0x40 #define IEGD_OVERLAY_FRAME 0x00 #define IEGD_OVERLAY_TOP 0x80 #define IEGD_OVERLAY_BOTTOM 0x00 #define IEGD_OVERLAY_WAIT_FLIP_DONE 0x100 #define IEGD_OVERLAY_IS_FLIP_DONE 0x200 #define IEGD_OVERLAY_OFF 0x80000000 #define IEGD_FW_VIDEO_OFF 0x40000000 typedef struct _iegd_esc_overlay { unsigned int drm_context; unsigned int src_buffer_id; unsigned int subpict_buffer_id; unsigned int drawable; unsigned int src_x1; unsigned int src_y1; unsigned int src_x2; unsigned int src_y2; unsigned int dest_x1; unsigned int dest_y1; unsigned int dest_x2; unsigned int dest_y2; unsigned int sub_x; unsigned int sub_y; unsigned int sub_dest_x; unsigned int sub_dest_y; unsigned int sub_width; unsigned int sub_height; unsigned int global_alpha; unsigned int chroma_low; unsigned int chroma_high; unsigned int flags; unsigned int num_clips; unsigned int scaling_workaround; /* clip_data x1,y1 -> x2, y2 */ } iegd_esc_overlay_t; typedef struct _iegd_esc_overlay_reply { iegd_surface_state_t surface_state; unsigned int sync_id; } iegd_esc_overlay_reply_t; typedef struct _iegd_esc_query_composite { unsigned int drawable; } iegd_esc_query_composite_t; typedef struct _iegd_esc_query_composite_reply { iegd_surface_state_t surface_state; } iegd_esc_query_composite_reply_t; /* * This is a CE-specific structure for handling video acceleration. This * structure is purposely made generic so that all video acceleration * functions can share this structure instead of defining a custom one * for each function. */ #define IEGD_EXECUTE_TYPE_VIDEO 1 #define IEGD_EXECUTE_TYPE_BLEND_3D 2 #define IEGD_EXECUTE_TYPE_2D 3 typedef struct _iegd_esc_video_buff_operation { void * ctx; unsigned char * virt; unsigned long offset; long type; /* only during buff execution - see IEGD_EXECUTE_TYPE_XXX above */ long size; int buffer_id; char start_of_data; /* !!MUST be last member!! */ } iegd_esc_video_buff_operation_t; #define IEGD_CLIENT_TYPE_3D 0x00000001 #define IEGD_CLIENT_TYPE_VIDEO 0x00000002 #define IEGD_CLIENT_TYPE_BLEND 0x00000004 typedef struct _iegd_esc_video_accel_ctx{ void * user_proc_handle; /* provided by the client */ unsigned long client_type; /* provided by the client - definitions above */ void * iegd_client_context; /* returned by the driver */ } iegd_esc_video_accel_ctx_t; #define IEGD_SYNC_TYPE_OP_MASK 0x0FFFFFFF #define IEGD_SYNC_TYPE_BLOCK 0x80000000 /* perform the sync operation as a blocking call * * only can be 'OR'-ed with IEGD_SYNC_TYPE_CHECK_X */ #define IEGD_SYNC_TYPE_GET_ID 0x00000001 /* get a sync number at current hardware rendering status */ #define IEGD_SYNC_TYPE_CHECK_ID 0x00000002 /* sync on the provided sync id * * number ifs its a non-blocking call,* * status will be 0 for SUCCESS * * or non-zero for busy */ #define IEGD_SYNC_TYPE_CHECK_CONTEXT_2D 0x00000004 #define IEGD_SYNC_TYPE_CHECK_CONTEXT_VIDEO 0x00000008 #define IEGD_SYNC_TYPE_CHECK_CONTEXT_3D 0x00000010 /* do a sync on the last execute_ * * buffer operation for this context */ typedef struct _iegd_esc_sync{ void * client_ctx; unsigned long sync_type; /* above IEGD_SYNC_TYPE_XXX */ unsigned long sync_id; int retval; /* 0 for success, non-zero for busy or failed */ } iegd_esc_sync_t; typedef struct _iegd_esc_overlay_quick_bypass { void * client_ctx; int src_priv_surf_id; int dst_ddraw_surf_id; } iegd_esc_overlay_quick_bypass_t; typedef struct _iegd_esc_wndobj_setup { void *hwnd; int enable; } iegd_esc_wndobj_setup_t; typedef struct _iegd_esc_wndobj_setup_reply { unsigned int drawable_id; } iegd_esc_wndobj_setup_reply_t; typedef struct _iegd_esc_dri_reply { unsigned int enabled; } iegd_esc_dri_reply_t; #if defined(USE_PRIVATE_DPM_MEM) typedef struct _iegd_esc_double_map { unsigned long offset; unsigned long size; } iegd_esc_double_map_t; typedef struct _iegd_esc_double_map_reply { unsigned long mapped_offset; } iegd_esc_double_map_reply_t; #endif typedef struct _iegd_esc_local_time { int sec; /* seconds after the minute - [0,59] */ int min; /* minutes after the hour - [0,59] */ int hour; /* hours since midnight - [0,23] */ int mday; /* day of the month - [1,31] */ int mon; /* months since January - [1,12] */ int year; /* year */ int wday; /* days since Sunday - [0,6] */ int yday; /* days since January 1 - [0,365] */ int is_dst; /* daylight savings time flag */ }igd_esc_local_time_t; typedef struct _iegd_esc_video_fps { unsigned int is_overlay; unsigned int is_hardware_decode; unsigned int is_interlaced_stream; int frame_count; igd_esc_local_time_t start_time; igd_esc_local_time_t end_time; }igd_esc_video_info_t; #endif