/*
 * 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