hal.h

epson公司的一个关于s1d13706的低层驱动程序

/*
**===========================================================================
** HAL.H
**---------------------------------------------------------------------------
** Copyright (c) 2000, 2001 Epson Research and Development, Inc.
** All Rights Reserved.
**===========================================================================
*/

#ifndef _HAL_H_
#define _HAL_H_

#ifdef   __GNUC__
#include "gnu.h"
#endif

// For testing
//#define DEBUG_SIMULATE_MEMORY

#include "hal_regs.h"

#if !defined(strcmpi)
#define strcmpi stricmp
#endif

#if !defined(SE_NODEFMAIN) && !defined(INTEL_W32) && !defined(INTEL_DOS)
#define main seMain
#define exit seExit

void seExit(int status);
#endif

//=======================================================================================

#if defined(INTEL_W32) || defined(INTEL_DOS)
// Do not include conio.h unless INCLUDE_CONIO_H is defined
#define INCLUDE_CONIO_H

// Do not include time.h unless INCLUDE_TIME_H is defined
#define INCLUDE_TIME_H
#pragma warning(disable:4032)  // disable warning: formal parameter 1 has different type when promoted
#endif

//=======================================================================================

#ifdef INTEL_W32
// Do not check for Windows PCI driver error codes unless WIN_PCI_DRIVER is defined
#define WIN_PCI_DRIVER
#endif

//=======================================================================================

#ifndef INTEL_DOS
// All platforms except DOS can use pointers to directly access display buffer memory.
#define LINEAR_ADDRESSES_SUPPORTED
#endif

//=======================================================================================

#ifdef INTEL_DOS
int getch(void);
#endif

#ifdef LCEVBSH3
#define getch getchar
int siprintf(char *, const char *, ...);
#endif

#ifdef IDP68K
int getch(void);
int siprintf(char *, const char *, ...);
#endif

#ifdef MPC8xx
#ifdef getchar
#undef getchar
#endif
int getch(void);
int siprintf(char *, const char *, ...);
#endif

#ifdef DSP56654ADM
int Printf(const char *, ...);
#define printf Printf
#endif

// embedded targets use non-float printf to reduce program size
#if defined(__GNUC__) && !defined(INTEL_DOS)
#ifdef BUSTED_UART
int Printf(const char *, ...);
#define printf Printf
#else
#define printf iprintf
#endif
#define fprintf fiprintf
#define sprintf siprintf
#define vprintf viprintf
#define vfprintf vfiprintf
#define vsprintf vsiprintf
#endif

#ifdef MPC8xx
int Write(int handle, const void *buffer, unsigned int count);
int Read(int handle, void *buffer, unsigned int count);
#endif

/*-------------------------------------------------------------------------*/

typedef unsigned char  BYTE;
typedef unsigned short WORD;
typedef unsigned long  DWORD;
typedef unsigned int   UINT;
typedef          int   BOOL;

#ifdef INTEL_DOS
 typedef BYTE  far *LPBYTE;
 typedef WORD  far *LPWORD;
 typedef DWORD far *LPDWORD;
#else
 typedef BYTE  *LPBYTE;
 typedef WORD  *LPWORD;
 typedef DWORD *LPDWORD;
#endif

#ifndef LOBYTE
#define LOBYTE(w)    ((BYTE)(w))
#endif

#ifndef HIBYTE
#define HIBYTE(w)    ((BYTE)(((UINT)(w) >> 8) & 0xFF))
#endif

#ifndef LOWORD
#define LOWORD(l)    ((WORD)(DWORD)(l))
#endif

#ifndef HIWORD
#define HIWORD(l)    ((WORD)((((DWORD)(l)) >> 16) & 0xFFFF))
#endif

#ifndef MAKEWORD
#define MAKEWORD(lo, hi) ((WORD)(((WORD)(lo)) | (((WORD)(hi)) << 8)) )
#endif

#ifndef MAKELONG
#define MAKELONG(lo, hi) ((long)(((WORD)(lo)) | (((DWORD)((WORD)(hi))) << 16)))
#endif

#ifndef TRUE
#define TRUE   1
#endif

#ifndef FALSE
#define FALSE  0
#endif

#ifndef NULL
#ifdef __cplusplus
#define NULL    0
#else 
#define NULL    ((void *)0)
#endif 
#endif 

/*-------------------------------------------------------------------------*/

/*
** SIZE_VERSION  is the size of the version string (eg. "1.00")
** SIZE_STATUS   is the size of the status string (eg. "b" for beta)
** SIZE_REVISION is the size of the status revision string (eg. "00")
*/
#define SIZE_VERSION    5
#define SIZE_STATUS     2
#define SIZE_REVISION   5

#ifdef __GNUC__
#define PACKED __attribute__((packed))
#else
#define PACKED
#endif

/*-------------------------------------------------------------------------*/

enum
{
   ERR_OK = 0,                      /* No error, call was successful. */
   ERR_FAILED,                      /* General purpose failure.       */

   ERR_UNKNOWN_DEVICE,
   ERR_INVALID_PARAMETER,     /* Function was called with invalid parameter. */
   ERR_HAL_BAD_ARG,
   ERR_INVALID_STD_DEVICE,

   ERR_PCI_DRIVER_NOT_FOUND,
   ERR_PCI_BRIDGE_ADAPTER_NOT_FOUND,

   ERR_CLKI_NOT_IN_TABLE,
   ERR_CLKI2_NOT_IN_TABLE,
   ERR_DISPLAY_NOT_ENABLED,
   ERR_NOT_ENOUGH_MEMORY,
   ERR_SWIVELVIEW_CLOCK
};


/*
** DetectEndian is used to determine whether the most significant
** and least significant bytes are reversed by the given compiler.
*/
#define ENDIAN       0x1234
#define REV_ENDIAN   0x3412


enum
{
   HAL_RED,
   HAL_GREEN,
   HAL_BLUE
};

/*************************************************************************/

/*
** Definitions for HAL_STRUCT.dwFlags
*/
#define fVALID_LCD         0x00000001
#define fFIXED_CLKI        0x00000002
#define fFIXED_CLKI2       0x00000004
#define fFIXED_DIVMCLK     0x00000008
#define fFIXED_DIVPCLK     0x00000010

/*************************************************************************/

/*
** Definitions for drawing functions
*/
#define MAIN_WIN     0x01
#define SUB_WIN      0x02


/*
** The S1D13706 cannot show more than 2 separate images (main window and sub-window).
*/
#define MAX_DISP_SURFACE   2

/*
** Definitions for seGetSwivelViewMode()
*/
#define LANDSCAPE   0x00
#define ROTATE90    0x01
#define ROTATE180   0x02
#define ROTATE270   (ROTATE90 | ROTATE180)

/*************************************************************************/

#pragma pack(1)

typedef struct
{
WORD index;
WORD val;   /* It is easier for the compiler to pack words instead of bytes. */
} PACKED defReg;

#define MAX_GCP_DATA   32


typedef struct tagHalStruct
{
   char  szIdString[16];
   WORD  wDetectEndian;
   WORD  wSize;

   DWORD dwFlags;
   defReg Regs[MAX_REG];
   BYTE  GcpData[MAX_GCP_DATA];

   DWORD dwClkI;                    /* Input Clock Frequency (in kHz) */
   DWORD dwClkI2;                   /* Input Clock 2 Frequency (in kHz) */
   DWORD dwBusClk;                  /* Bus Clock Frequency (in kHz) */
   DWORD dwRegisterAddress;         /* Starting address of registers */
   DWORD dwDisplayMemoryAddress;    /* Starting address of display buffer memory */
   WORD  wPanelFrameRate;           /* Desired panel frame rate */
   WORD  wLcdPowerdownTime;         /* Time before LCD loses power (in milliseconds) */
   WORD  wLcdPowerupTime;           /* Time before LCD gets power (in milliseconds) */
   WORD  wReserved0;                /* */
   WORD  wReserved1;                /* */
   WORD  wReserved2;                /* */
} PACKED HAL_STRUCT;

#pragma pack()

typedef HAL_STRUCT * PHAL_STRUCT;

#ifdef INTEL_DOS
 typedef HAL_STRUCT far * LPHAL_STRUCT;
#else
 typedef HAL_STRUCT * LPHAL_STRUCT;
#endif

/*=========================================================================*/
/*                         FUNCTION  PROTO-TYPES                           */
/*=========================================================================*/


/*---------------------------- HAL Support --------------------------------*/

int seRegisterDevice(const LPHAL_STRUCT lpHalInfo);
int seHalTerminate(void);
DWORD seGetInstalledMemorySize(void);
int seEnableHardwareDisplaySwapping(int enable);

/*
** Definitions for flags in seInitReg()
*/
#define CLEAR_MEM          0x0001
#define DISP_BLANK         0x0002

int seInitReg(unsigned flags);

int  seGetId( int *pId );
void seGetHalVersion( const char **pVersion, const char **pStatus, const char **pRevision );

/*---------------------------- Chip Access --------------------------------*/

unsigned seReadRegByte(DWORD index);
void seWriteRegByte(DWORD index, unsigned value);
unsigned seReadRegWord(DWORD index);
void seWriteRegWord(DWORD index, unsigned value);
DWORD seReadRegDword(DWORD index);
void seWriteRegDword(DWORD index, DWORD value);

/*------------------------------- Misc ------------------------------------*/

int seCheckSwivelViewClocks(unsigned BitsPerPixel, unsigned SwivelViewMode);
int seSetSwivelViewMode(int rotate);
int seGetSwivelViewMode(void);

// seGetLcdOrientation() is a legacy function. It is recommended to use seGetSwivelViewMode() instead.
int seGetLcdOrientation(void);

int seGetSurfaceDisplayMode(void);
DWORD seGetSurfaceSize(void);
DWORD seGetSurfaceLinearAddress(void);
DWORD seGetSurfaceOffsetAddress(void);
DWORD seAllocMainWinSurface(DWORD size);
DWORD seAllocSubWinSurface(DWORD size);
int seFreeSurface(DWORD LinearAddress);
void seSetMainWinAsActiveSurface(void);
void seSetSubWinAsActiveSurface(void);

// seSetBitsPerPixel() is a legacy function. It is recommended to use seSetMode() instead.
int seSetBitsPerPixel(unsigned nBitsPerPixel);

int seSetMode(unsigned nBitsPerPixel);
void seUseMainWinImageForSubWin(void);
unsigned seGetBitsPerPixel(void);
DWORD seGetAvailableMemorySize(void);

void seMainWinDisplayBlank(BOOL activate);
void seSubWinDisplayBlank(BOOL activate);
void seDisplayBlank(BOOL activate);

void seMainWinDisplayEnable(BOOL activate);
void seSubWinDisplayEnable(BOOL activate);
void seDisplayEnable(BOOL activate);

int seDelay(DWORD Seconds);

unsigned seGetMainWinBytesPerScanline(void);
unsigned seGetSubWinBytesPerScanline(void);
unsigned seGetBytesPerScanline(void);

void seGetMainWinResolution(unsigned *width, unsigned *height);
void seGetSubWinResolution(unsigned *width, unsigned *height);
void seSetSubWinCoordinates(DWORD x1, DWORD y1, DWORD x2, DWORD y2);
void seGetSubWinCoordinates(DWORD *x1, DWORD *y1, DWORD *x2, DWORD *y2);
int seGetResolution(unsigned *width, unsigned *height);

void seSetPowerSaveMode(BOOL enable);
BOOL seGetPowerSaveMode(void);

void seCheckEndian(BOOL *ReverseBytes);
void seSetPowerUpDelay(WORD wLcdPowerupTime);
void seSetPowerDownDelay(WORD wLcdPowerdownTime);

int seVirtInit(DWORD width, DWORD height);
int seMainWinVirtInit(DWORD width, DWORD height);
int seSubWinVirtInit(DWORD width, DWORD height);
int seMainAndSubWinVirtInit(DWORD width, DWORD height);

void seVirtPanScroll(DWORD x, DWORD y);
void seMainWinVirtPanScroll(DWORD x, DWORD y);
void seSubWinVirtPanScroll(DWORD x, DWORD y);
void seMainAndSubWinVirtPanScroll(DWORD x, DWORD y);

/*------------------------- Priority ---------------------------------*/

int seBeginHighPriority(void);
int seEndHighPriority(void);

/*------------------------- Memory Access ---------------------------------*/

unsigned seReadDisplayByte(DWORD offset);
unsigned seReadDisplayWord(DWORD offset);
DWORD seReadDisplayDword(DWORD offset);

void seWriteDisplayBytes(DWORD offset, unsigned val, DWORD count);
void seWriteDisplayWords(DWORD offset, unsigned val, DWORD count);
void seWriteDisplayDwords(DWORD offset, DWORD val, DWORD count);

/*------------------------------- Drawing ---------------------------------*/

void seSetMainWinPixel(long x, long y, DWORD color);
void seSetSubWinPixel(long x, long y, DWORD color);
void seSetPixel(long x, long y, DWORD color);

DWORD seGetMainWinPixel(long x, long y);
DWORD seGetSubWinPixel(long x, long y);
DWORD seGetPixel(long x, long y);

void seDrawMainWinLine(long x1, long y1, long x2, long y2, DWORD color);
void seDrawSubWinLine(long x1, long y1, long x2, long y2, DWORD color);
void seDrawLine(long x1, long y1, long x2, long y2, DWORD color);

void seDrawMainWinRect(long x1, long y1, long x2, long y2, DWORD color, BOOL SolidFill);
void seDrawSubWinRect(long x1, long y1, long x2, long y2, DWORD color, BOOL SolidFill);
void seDrawRect(long x1, long y1, long x2, long y2, DWORD color, BOOL SolidFill);

void seDrawMainWinEllipse(long xc, long yc, long xr, long yr, DWORD color);
void seDrawSubWinEllipse(long xc, long yc, long xr, long yr, DWORD color);
void seDrawEllipse(long xc, long yc, long xr, long yr, DWORD color);

void seDrawMainWinCircle(long xCenter, long yCenter, long radius, DWORD color);
void seDrawSubWinCircle(long xCenter, long yCenter, long radius, DWORD color);
void seDrawCircle(long xCenter, long yCenter, long radius, DWORD color);

/*------------------------------ Color ------------------------------------*/

void seWriteLut(BYTE *pLut, int count);
void seReadLut(BYTE *pLut, int count);

void seWriteLutEntry(int index, BYTE *pColor);
void seReadLutEntry(int index, BYTE *pColor);

/*--------------------------- PCI Support --------------------------------*/

DWORD seGetLinearDisplayAddress(void);
DWORD seGetLinearRegAddress(void);

/*--------------------- Programmable Clock Chip Support ------------------*/

typedef enum
{
   FREQ_6000 = 0,   /*   6.000 MHz */
   FREQ_10000,      /*  10.000 MHz */
   FREQ_14318,      /*  14.318 MHz */
   FREQ_17734,      /*  17.734 MHz */
   FREQ_20000,      /*  20.000 MHz */
   FREQ_24000,      /*  24.000 MHz */
   FREQ_25000,      /*  25.000 MHz */
   FREQ_25175,      /*  25.175 MHz */
   FREQ_28318,      /*  28.318 MHz */
   FREQ_30000,      /*  30.000 MHz */
   FREQ_31500,      /*  31.500 MHz */
   FREQ_32000,      /*  32.000 MHz */
   FREQ_33000,      /*  33.000 MHz */
   FREQ_33333,      /*  33.333 MHz */
   FREQ_34000,      /*  34.000 MHz */
   FREQ_35000,      /*  35.000 MHz */
   FREQ_36000,      /*  36.000 MHz */
   FREQ_40000,      /*  40.000 MHz */
   FREQ_49500,      /*  49.500 MHz */
   FREQ_50000,      /*  50.000 MHz */
   FREQ_56250,      /*  56.250 MHz */
   FREQ_65000,      /*  65.000 MHz */
   FREQ_80000,      /*  80.000 MHz */
   FREQ_100000,     /* 100.000 MHz */

   MAX_FREQ_INDEX
}FREQINDEX;


#define FREQ_FEATCLK   FREQ_17734


typedef enum
{
   CLKI = 0,
   CLKI2
} CLOCKSELECT;

int seSetClock(CLOCKSELECT clock, FREQINDEX FreqIndex);

/*--------------------------- PWM/CV Support --------------------------------*/

void sePwmEnable(int enable);
void seCvEnable(int enable);

void sePwmControl(CLOCKSELECT ClkSource, int ClkDivide, int DutyCycle);
void seCvControl(CLOCKSELECT ClkSource, int ClkDivide, int BurstLength);

/*------------------------------------------------------------------------*/

#endif      /* _HAL_H_ */