358 lines
11 KiB
C
358 lines
11 KiB
C
/*
|
|
* Copyright 2009-2012, Haiku, Inc. All rights reserved.
|
|
* Distributed under the terms of the MIT License.
|
|
*/
|
|
#ifndef _ACCELERANT_H_
|
|
#define _ACCELERANT_H_
|
|
|
|
|
|
#include <GraphicsDefs.h>
|
|
#include <OS.h>
|
|
|
|
|
|
#if defined(__cplusplus)
|
|
extern "C" {
|
|
#endif
|
|
|
|
|
|
#define B_ACCELERANT_ENTRY_POINT "get_accelerant_hook"
|
|
#define B_ACCELERANT_VERSION 1
|
|
|
|
|
|
typedef void* (*GetAccelerantHook)(uint32, void*);
|
|
|
|
void* get_accelerant_hook(uint32 feature, void* data);
|
|
|
|
|
|
enum {
|
|
/* initialization */
|
|
B_INIT_ACCELERANT = 0, /* required */
|
|
B_ACCELERANT_CLONE_INFO_SIZE, /* required */
|
|
B_GET_ACCELERANT_CLONE_INFO, /* required */
|
|
B_CLONE_ACCELERANT, /* required */
|
|
B_UNINIT_ACCELERANT, /* required */
|
|
B_GET_ACCELERANT_DEVICE_INFO, /* required */
|
|
B_ACCELERANT_RETRACE_SEMAPHORE, /* optional */
|
|
|
|
/* mode configuration */
|
|
B_ACCELERANT_MODE_COUNT = 0x100, /* required */
|
|
B_GET_MODE_LIST, /* required */
|
|
B_PROPOSE_DISPLAY_MODE, /* optional */
|
|
B_SET_DISPLAY_MODE, /* required */
|
|
B_GET_DISPLAY_MODE, /* required */
|
|
B_GET_FRAME_BUFFER_CONFIG, /* required */
|
|
B_GET_PIXEL_CLOCK_LIMITS, /* required */
|
|
B_GET_TIMING_CONSTRAINTS, /* optional */
|
|
B_MOVE_DISPLAY, /* optional */
|
|
B_SET_INDEXED_COLORS, /* required if driver supports 8bit */
|
|
/* indexed modes */
|
|
B_DPMS_CAPABILITIES, /* required if driver supports DPMS */
|
|
B_DPMS_MODE, /* required if driver supports DPMS */
|
|
B_SET_DPMS_MODE, /* required if driver supports DPMS */
|
|
B_GET_PREFERRED_DISPLAY_MODE, /* optional */
|
|
B_GET_MONITOR_INFO, /* optional */
|
|
B_GET_EDID_INFO, /* optional */
|
|
B_SET_BRIGHTNESS, /* optional */
|
|
B_GET_BRIGHTNESS, /* optional */
|
|
|
|
/* cursor managment */
|
|
B_MOVE_CURSOR = 0x200, /* optional */
|
|
B_SET_CURSOR_SHAPE, /* optional */
|
|
B_SHOW_CURSOR, /* optional */
|
|
B_SET_CURSOR_BITMAP, /* optional */
|
|
|
|
/* synchronization */
|
|
B_ACCELERANT_ENGINE_COUNT = 0x300, /* required */
|
|
B_ACQUIRE_ENGINE, /* required */
|
|
B_RELEASE_ENGINE, /* required */
|
|
B_WAIT_ENGINE_IDLE, /* required */
|
|
B_GET_SYNC_TOKEN, /* required */
|
|
B_SYNC_TO_TOKEN, /* required */
|
|
|
|
/* 2D acceleration */
|
|
B_SCREEN_TO_SCREEN_BLIT = 0x400, /* optional */
|
|
B_FILL_RECTANGLE, /* optional */
|
|
B_INVERT_RECTANGLE, /* optional */
|
|
B_FILL_SPAN, /* optional */
|
|
B_SCREEN_TO_SCREEN_TRANSPARENT_BLIT, /* optional */
|
|
B_SCREEN_TO_SCREEN_SCALED_FILTERED_BLIT, /* optional.
|
|
NOTE: source and dest may NOT overlap */
|
|
|
|
/* 3D acceleration */
|
|
B_ACCELERANT_PRIVATE_START = (int)0x80000000
|
|
};
|
|
|
|
|
|
typedef struct {
|
|
uint32 version; /* structure version number */
|
|
char name[32]; /* a name the user will recognize */
|
|
/* the device by */
|
|
char chipset[32]; /* the chipset used by the device */
|
|
char serial_no[32]; /* serial number for the device */
|
|
uint32 memory; /* amount of memory on the device, */
|
|
/* in bytes */
|
|
uint32 dac_speed; /* nominal DAC speed, in MHz */
|
|
} accelerant_device_info;
|
|
|
|
|
|
typedef struct {
|
|
uint32 pixel_clock; /* kHz */
|
|
uint16 h_display; /* in pixels (not character clocks) */
|
|
uint16 h_sync_start;
|
|
uint16 h_sync_end;
|
|
uint16 h_total;
|
|
uint16 v_display; /* in lines */
|
|
uint16 v_sync_start;
|
|
uint16 v_sync_end;
|
|
uint16 v_total;
|
|
uint32 flags; /* sync polarity, etc. */
|
|
} display_timing;
|
|
|
|
|
|
typedef struct {
|
|
display_timing timing; /* CTRC info */
|
|
uint32 space; /* pixel configuration */
|
|
uint16 virtual_width; /* in pixels */
|
|
uint16 virtual_height; /* in lines */
|
|
uint16 h_display_start; /* first displayed pixel in line */
|
|
uint16 v_display_start; /* first displayed line */
|
|
uint32 flags; /* mode flags (Some drivers use this */
|
|
/* for dual head related options.) */
|
|
} display_mode;
|
|
|
|
typedef struct {
|
|
void* frame_buffer; /* pointer to first byte of frame */
|
|
/* buffer in virtual memory */
|
|
|
|
void* frame_buffer_dma; /* pointer to first byte of frame */
|
|
/* buffer in physical memory for DMA */
|
|
|
|
uint32 bytes_per_row; /* number of bytes in one */
|
|
/* virtual_width line */
|
|
/* not neccesarily the same as */
|
|
/* virtual_width * byte_per_pixel */
|
|
} frame_buffer_config;
|
|
|
|
|
|
typedef struct {
|
|
uint16 h_res; /* minimum effective change in */
|
|
/* horizontal pixels, usually 8 */
|
|
|
|
uint16 h_sync_min; /* min/max horizontal sync pulse */
|
|
/* width in pixels, a multiple of */
|
|
/* h_res */
|
|
uint16 h_sync_max;
|
|
uint16 h_blank_min; /* min/max horizontal blank pulse */
|
|
/* width in pixels, a multiple of */
|
|
/* h_res */
|
|
uint16 h_blank_max;
|
|
uint16 v_res; /* minimum effective change in */
|
|
/* vertical lines, usually 1 */
|
|
|
|
uint16 v_sync_min; /* min/max vertical sync pulse */
|
|
/* width in lines, a multiple of */
|
|
/* v_res */
|
|
uint16 v_sync_max;
|
|
uint16 v_blank_min; /* min/max vertical blank pulse */
|
|
/* width in linex, a multiple of */
|
|
/* v_res */
|
|
uint16 v_blank_max;
|
|
} display_timing_constraints;
|
|
|
|
|
|
// WARNING: This is experimental new Haiku API
|
|
typedef struct {
|
|
uint32 version;
|
|
char vendor[128];
|
|
char name[128];
|
|
char serial_number[128];
|
|
uint32 product_id;
|
|
struct {
|
|
uint16 week;
|
|
uint16 year;
|
|
} produced;
|
|
float width;
|
|
float height;
|
|
uint32 min_horizontal_frequency; /* in kHz */
|
|
uint32 max_horizontal_frequency;
|
|
uint32 min_vertical_frequency; /* in Hz */
|
|
uint32 max_vertical_frequency;
|
|
uint32 max_pixel_clock; /* in kHz */
|
|
} monitor_info;
|
|
|
|
|
|
/* mode flags */
|
|
enum {
|
|
B_SCROLL = 1 << 0,
|
|
B_8_BIT_DAC = 1 << 1,
|
|
B_HARDWARE_CURSOR = 1 << 2,
|
|
B_PARALLEL_ACCESS = 1 << 3,
|
|
B_DPMS = 1 << 4,
|
|
B_IO_FB_NA = 1 << 5
|
|
};
|
|
|
|
|
|
/* power saver flags */
|
|
enum {
|
|
B_DPMS_ON = 1 << 0,
|
|
B_DPMS_STAND_BY = 1 << 1,
|
|
B_DPMS_SUSPEND = 1 << 2,
|
|
B_DPMS_OFF = 1 << 3
|
|
};
|
|
|
|
|
|
/* timing flags */
|
|
enum {
|
|
B_BLANK_PEDESTAL = 1 << 27,
|
|
B_TIMING_INTERLACED = 1 << 28,
|
|
B_POSITIVE_HSYNC = 1 << 29,
|
|
B_POSITIVE_VSYNC = 1 << 30,
|
|
B_SYNC_ON_GREEN = 1 << 31
|
|
};
|
|
|
|
|
|
typedef struct {
|
|
uint16 src_left; /* guaranteed constrained to */
|
|
/* virtual width and height */
|
|
uint16 src_top;
|
|
uint16 dest_left;
|
|
uint16 dest_top;
|
|
uint16 width; /* 0 to N, where zero means */
|
|
/* one pixel, one means two pixels, */
|
|
/* etc. */
|
|
uint16 height; /* 0 to M, where zero means one */
|
|
/* line, one means two lines, etc. */
|
|
} blit_params;
|
|
|
|
|
|
typedef struct {
|
|
uint16 src_left; /* guaranteed constrained to */
|
|
/* virtual width and height */
|
|
uint16 src_top;
|
|
uint16 src_width; /* 0 to N, where zero means one */
|
|
/* pixel, one means two pixels, */
|
|
/* etc. */
|
|
uint16 src_height; /* 0 to M, where zero means one */
|
|
/* line, one means two lines, etc. */
|
|
uint16 dest_left;
|
|
uint16 dest_top;
|
|
uint16 dest_width; /* 0 to N, where zero means one */
|
|
/* pixel, one means two pixels, etc. */
|
|
uint16 dest_height; /* 0 to M, where zero means one */
|
|
/* line, one means two lines, etc. */
|
|
} scaled_blit_params;
|
|
|
|
|
|
typedef struct {
|
|
uint16 left; /* guaranteed constrained to */
|
|
/* virtual width and height */
|
|
uint16 top;
|
|
uint16 right;
|
|
uint16 bottom;
|
|
} fill_rect_params;
|
|
|
|
|
|
typedef struct {
|
|
uint32 engine_id; /* 0 == no engine, 1,2,3 etc */
|
|
/* individual engines */
|
|
uint32 capability_mask; /* features this engine supports */
|
|
void* opaque; /* optional pointer to engine */
|
|
/* private storage */
|
|
} engine_token;
|
|
|
|
|
|
enum { /* engine capabilities */
|
|
B_2D_ACCELERATION = 1 << 0,
|
|
B_3D_ACCELERATION = 1 << 1
|
|
};
|
|
|
|
|
|
typedef struct {
|
|
uint64 counter; /* counts issued primatives */
|
|
uint32 engine_id; /* what engine the counter is for */
|
|
char opaque[12]; /* 12 bytes of private storage */
|
|
} sync_token;
|
|
|
|
|
|
/* Masks for color info */
|
|
/* B_CMAP8 - 0x000000ff */
|
|
/* B_RGB15/16 - 0x0000ffff */
|
|
/* B_RGB24 - 0x00ffffff */
|
|
/* B_RGB32 - 0xffffffff */
|
|
|
|
typedef status_t (*init_accelerant)(int fd);
|
|
typedef ssize_t (*accelerant_clone_info_size)(void);
|
|
typedef void (*get_accelerant_clone_info)(void* data);
|
|
typedef status_t (*clone_accelerant)(void* data);
|
|
typedef void (*uninit_accelerant)(void);
|
|
typedef status_t (*get_accelerant_device_info)(accelerant_device_info* adi);
|
|
|
|
typedef uint32 (*accelerant_mode_count)(void);
|
|
typedef status_t (*get_mode_list)(display_mode*);
|
|
typedef status_t (*propose_display_mode)(display_mode* target,
|
|
display_mode* low, display_mode* high);
|
|
typedef status_t (*set_display_mode)(display_mode* modeToSet);
|
|
typedef status_t (*get_display_mode)(display_mode* currentMode);
|
|
typedef status_t (*get_frame_buffer_config)(frame_buffer_config* frameBuffer);
|
|
typedef status_t (*get_pixel_clock_limits)(display_mode* dm, uint32* low,
|
|
uint32* high);
|
|
typedef status_t (*move_display_area)(uint16 hDisplayStart,
|
|
uint16 vDisplayStart);
|
|
typedef status_t (*get_timing_constraints)(display_timing_constraints* dtc);
|
|
typedef void (*set_indexed_colors)(uint count, uint8 first,
|
|
const uint8* colorData, uint32 flags);
|
|
typedef uint32 (*dpms_capabilities)(void);
|
|
typedef uint32 (*dpms_mode)(void);
|
|
typedef status_t (*set_dpms_mode)(uint32 dpms_flags);
|
|
typedef status_t (*get_preferred_display_mode)(display_mode* preferredMode);
|
|
typedef status_t (*get_monitor_info)(monitor_info* info);
|
|
typedef status_t (*get_edid_info)(void* info, uint32 size, uint32* _version);
|
|
typedef status_t (*set_brightness)(float brightness);
|
|
typedef status_t (*get_brightness)(float* brightness);
|
|
|
|
typedef sem_id (*accelerant_retrace_semaphore)(void);
|
|
|
|
typedef status_t (*set_cursor_shape)(uint16 width, uint16 height,
|
|
uint16 hotX, uint16 hotY, const uint8* andMask, const uint8* xorMask);
|
|
typedef status_t (*set_cursor_bitmap)(uint16 width, uint16 height,
|
|
uint16 hotX, uint16 hotY, color_space colorSpace, uint16 bytesPerRow,
|
|
const uint8* bitmapData);
|
|
typedef void (*move_cursor)(uint16 x, uint16 y);
|
|
typedef void (*show_cursor)(bool isVisible);
|
|
|
|
typedef uint32 (*accelerant_engine_count)(void);
|
|
typedef status_t (*acquire_engine)(uint32 capabilities, uint32 maxWait,
|
|
sync_token* st, engine_token** et);
|
|
typedef status_t (*release_engine)(engine_token* et, sync_token* st);
|
|
typedef void (*wait_engine_idle)(void);
|
|
typedef status_t (*get_sync_token)(engine_token* et, sync_token* st);
|
|
typedef status_t (*sync_to_token)(sync_token* st);
|
|
|
|
typedef void (*screen_to_screen_blit)(engine_token* et, blit_params* list,
|
|
uint32 count);
|
|
typedef void (*fill_rectangle)(engine_token* et, uint32 color,
|
|
fill_rect_params* list, uint32 count);
|
|
typedef void (*invert_rectangle)(engine_token* et, fill_rect_params* list,
|
|
uint32 count);
|
|
typedef void (*screen_to_screen_transparent_blit)(engine_token* et,
|
|
uint32 transparent_color, blit_params* list, uint32 count);
|
|
typedef void (*screen_to_screen_scaled_filtered_blit)(engine_token* et,
|
|
scaled_blit_params* list, uint32 count);
|
|
|
|
typedef void (*fill_span)(engine_token* et, uint32 color, uint16* list,
|
|
uint32 count);
|
|
/*
|
|
The uint16* list points to a list of tripples:
|
|
list[N+0] Y co-ordinate of span
|
|
list[N+1] Left x co-ordinate of span
|
|
list[N+2] Right x co-ordinate of span
|
|
where N is in the range 0 to count-1.
|
|
*/
|
|
|
|
|
|
#if defined(__cplusplus)
|
|
}
|
|
#endif
|
|
|
|
#endif
|