pmapi.h

来自「适合KS8695X」· C头文件 代码 · 共 1,149 行 · 第 1/4 页

for physical memory mapping. This is used for framebuffer write combing and
speeds up direct framebuffer writes to the memory.

The PM_agpIntelDCACHE type indicates that memory should come from the Intel
i81x Display Cache (or DCACHE) memory pool. This flag is specific to the
Intel i810 and i815 controllers, and should not be passed for any other
controller type.

HEADER:
pmapi.h

MEMBERS:
PM_agpUncached      - Indicates that the memory should be uncached
PM_agpWriteCombine  - Indicates that the memory should be write combined
PM_agpIntelDCACHE   - Indicates that the memory should come from DCACHE pool
****************************************************************************/
typedef enum {
    PM_agpUncached,
    PM_agpWriteCombine,
    PM_agpIntelDCACHE
    } PM_agpMemoryType;

/* Defines the size of an system memory page */

#define PM_PAGE_SIZE        4096

/* Type definition for a physical memory address */

typedef unsigned long PM_physAddr;

/* Define a bad physical address returned by map physical functions */

#define PM_BAD_PHYS_ADDRESS 0xFFFFFFFF

/* Type definition for the 12-byte lock handle for locking linear memory */

typedef struct {
    ulong   h[3];
    } PM_lockHandle;

/* 'C' calling conventions always       */

#define PMAPI   _ASMAPI
#define PMAPIP  _ASMAPIP

/* Internal typedef to override DPMI_int86 handler */

typedef ibool (PMAPIP DPMI_handler_t)(DPMI_regs *regs);
void PMAPI DPMI_setInt10Handler(DPMI_handler_t handler);

/* Type definitions for a window handle for console modes */

#if     defined(__DRIVER__) || defined(__WIN32_VXD__) || defined(__NT_DRIVER__)
typedef void        *PM_HWND;   /* Pointer for portable drivers         */
typedef void        *PM_MODULE; /* Module handle for portable drivers   */
#elif   defined(__WINDOWS__)
#ifdef  DECLARE_HANDLE
typedef HWND        PM_HWND;    /* Real window handle                   */
typedef HINSTANCE   PM_MODULE;  /* Win32 DLL handle                     */
#else
typedef void        *PM_HWND;   /* Place holder if windows.h not included */
typedef void        *PM_MODULE; /* Place holder if windows.h not included */
#endif
#elif   defined(__USE_X11__)
typedef struct {
    Window      *window;
    Display     *display;
    } PM_HWND;                  /* X11 window handle */
#elif   defined(__OS2__)
typedef void    *PM_HWND;
typedef void    *PM_MODULE;
#elif   defined(__LINUX__)
typedef int     PM_HWND;        /* Console id for fullscreen Linux */
typedef void    *PM_MODULE;
#elif   defined(__QNX__)
typedef int     PM_HWND;        /* Console id for fullscreen QNX */
typedef void    *PM_MODULE;
#elif   defined(__RTTARGET__)
typedef int     PM_HWND;        /* Placeholder for RTTarget-32 */
typedef void    *PM_MODULE;
#elif   defined(__REALDOS__)
typedef int     PM_HWND;        /* Placeholder for fullscreen DOS */
typedef void    *PM_MODULE;     /* Placeholder for fullscreen DOS */
#elif   defined(__SMX32__)
typedef int     PM_HWND;        /* Placeholder for fullscreen SMX */
typedef void    *PM_MODULE;
#elif   defined(__SNAP__)
typedef void    *PM_HWND;
typedef void    *PM_MODULE;
#else
#error  PM library not ported to this platform yet!
#endif

/* Type definition for code pointers */

typedef void (*__codePtr)();

/* Type definition for a C based interrupt handler */

typedef void (PMAPIP PM_intHandler)(void);
typedef ibool (PMAPIP PM_irqHandler)(void);

/* Hardware IRQ handle used to save and restore the hardware IRQ */

typedef void *PM_IRQHandle;

/* Type definition for the fatal cleanup handler */

typedef void (PMAPIP PM_fatalCleanupHandler)(void);

/* Type defifinition for save state callback function */

typedef int (PMAPIP PM_saveState_cb)(int flags);

/* Type definintion for enum write combined callback function */

typedef void (PMAPIP PM_enumWriteCombine_t)(ulong base,ulong length,uint type);

/* Structure defining all the PM API functions as exported to
 * the binary portable DLL's.
 */

typedef struct {
    ulong   dwSize;
    int     (PMAPIP PM_getModeType)(void);
    void *  (PMAPIP PM_getBIOSPointer)(void);
    void *  (PMAPIP PM_getA0000Pointer)(void);
    void *  (PMAPIP PM_mapPhysicalAddr)(ulong base,ulong limit,ibool isCached);
    void *  (PMAPIP PM_mallocShared)(long size);
    void *  reserved1;
    void    (PMAPIP PM_freeShared)(void *ptr);
    void *  (PMAPIP PM_mapToProcess)(void *linear,ulong limit);
    void *  (PMAPIP PM_mapRealPointer)(uint r_seg,uint r_off);
    void *  (PMAPIP PM_allocRealSeg)(uint size,uint *r_seg,uint *r_off);
    void    (PMAPIP PM_freeRealSeg)(void *mem);
    void *  (PMAPIP PM_allocLockedMem)(uint size,ulong *physAddr,ibool contiguous,ibool below16Meg);
    void    (PMAPIP PM_freeLockedMem)(void *p,uint size,ibool contiguous);
    void    (PMAPIP PM_callRealMode)(uint seg,uint off, RMREGS *regs,RMSREGS *sregs);
    int     (PMAPIP PM_int86)(int intno, RMREGS *in, RMREGS *out);
    int     (PMAPIP PM_int86x)(int intno, RMREGS *in, RMREGS *out,RMSREGS *sregs);
    void    (PMAPIP DPMI_int86)(int intno, DPMI_regs *regs);
    void    (PMAPIP PM_availableMemory)(ulong *physical,ulong *total);
    void *  (PMAPIP PM_getVESABuf)(uint *len,uint *rseg,uint *roff);
    long    (PMAPIP PM_getOSType)(void);
    void    (PMAPIP PM_fatalError)(const char *msg);
    void    (PMAPIP PM_setBankA)(int bank);
    void    (PMAPIP PM_setBankAB)(int bank);
    void    (PMAPIP PM_setCRTStart)(int x,int y,int waitVRT);
    char *  (PMAPIP PM_getCurrentPath)(char *path,int maxLen);
    const char * (PMAPIP PM_getVBEAFPath)(void);
    const char * (PMAPIP PM_getNucleusPath)(void);
    const char * (PMAPIP PM_getNucleusConfigPath)(void);
    const char * (PMAPIP PM_getUniqueID)(void);
    const char * (PMAPIP PM_getMachineName)(void);
    ibool   (PMAPIP VF_available)(void);
    void *  (PMAPIP VF_init)(ulong baseAddr,int bankSize,int codeLen,void *bankFunc);
    void    (PMAPIP VF_exit)(void);
    PM_HWND (PMAPIP PM_openConsole)(PM_HWND hwndUser,int device,int xRes,int yRes,int bpp,ibool fullScreen);
    int     (PMAPIP PM_getConsoleStateSize)(void);
    void    (PMAPIP PM_saveConsoleState)(void *stateBuf,PM_HWND hwndConsole);
    void    (PMAPIP PM_restoreConsoleState)(const void *stateBuf,PM_HWND hwndConsole);
    void    (PMAPIP PM_closeConsole)(PM_HWND hwndConsole);
    void    (PMAPIP PM_setOSCursorLocation)(int x,int y);
    void    (PMAPIP PM_setOSScreenWidth)(int width,int height);
    int     (PMAPIP PM_enableWriteCombine)(ulong base,ulong length,uint type);
    void    (PMAPIP PM_backslash)(char *filename);
    int     (PMAPIP PM_lockDataPages)(void *p,uint len,PM_lockHandle *lockHandle);
    int     (PMAPIP PM_unlockDataPages)(void *p,uint len,PM_lockHandle *lockHandle);
    int     (PMAPIP PM_lockCodePages)(__codePtr p,uint len,PM_lockHandle *lockHandle);
    int     (PMAPIP PM_unlockCodePages)(__codePtr p,uint len,PM_lockHandle *lockHandle);
    ibool   (PMAPIP PM_setRealTimeClockHandler)(PM_intHandler ih,int frequency);
    void    (PMAPIP PM_setRealTimeClockFrequency)(int frequency);
    void    (PMAPIP PM_restoreRealTimeClockHandler)(void);
    ibool   (PMAPIP PM_doBIOSPOST)(ushort axVal,ulong BIOSPhysAddr,void *BIOSPtr,ulong BIOSLen);
    char    (PMAPIP PM_getBootDrive)(void);
    void    (PMAPIP PM_freePhysicalAddr)(void *ptr,ulong limit);
    uchar   (PMAPIP PM_inpb)(int port);
    ushort  (PMAPIP PM_inpw)(int port);
    ulong   (PMAPIP PM_inpd)(int port);
    void    (PMAPIP PM_outpb)(int port,uchar val);
    void    (PMAPIP PM_outpw)(int port,ushort val);
    void    (PMAPIP PM_outpd)(int port,ulong val);
    void *  reserved2;
    void    (PMAPIP PM_setSuspendAppCallback)(PM_saveState_cb saveState);
    ibool   (PMAPIP PM_haveBIOSAccess)(void);
    int     (PMAPIP PM_kbhit)(void);
    int     (PMAPIP PM_getch)(void);
    ibool   (PMAPIP PM_findBPD)(const char *dllname,char *bpdpath);
    ulong   (PMAPIP PM_getPhysicalAddr)(void *p);
    void    (PMAPIP PM_sleep)(ulong milliseconds);
    int     (PMAPIP PM_getCOMPort)(int port);
    int     (PMAPIP PM_getLPTPort)(int port);
    PM_MODULE (PMAPIP PM_loadLibrary)(const char *szDLLName);
    void *  (PMAPIP PM_getProcAddress)(PM_MODULE hModule,const char *szProcName);
    void    (PMAPIP PM_freeLibrary)(PM_MODULE hModule);
    int     (PMAPIP PCI_enumerate)(PCIDeviceInfo info[]);
    ulong   (PMAPIP PCI_accessReg)(int index,ulong value,int func,PCIDeviceInfo *info);
    ibool   (PMAPIP PCI_setHardwareIRQ)(PCIDeviceInfo *info,uint intPin,uint IRQ);
    void    (PMAPIP PCI_generateSpecialCyle)(uint bus,ulong specialCycleData);
    void *  reserved3;
    ulong   (PMAPIP PCIBIOS_getEntry)(void);
    uint    (PMAPIP CPU_getProcessorType)(void);
    ibool   (PMAPIP CPU_haveMMX)(void);
    ibool   (PMAPIP CPU_have3DNow)(void);
    ibool   (PMAPIP CPU_haveSSE)(void);
    ibool   (PMAPIP CPU_haveRDTSC)(void);
    ulong   (PMAPIP CPU_getProcessorSpeed)(ibool accurate);
    void    (PMAPIP ZTimerInit)(void);
    void    (PMAPIP LZTimerOn)(void);
    ulong   (PMAPIP LZTimerLap)(void);
    void    (PMAPIP LZTimerOff)(void);
    ulong   (PMAPIP LZTimerCount)(void);
    void    (PMAPIP LZTimerOnExt)(LZTimerObject *tm);
    ulong   (PMAPIP LZTimerLapExt)(LZTimerObject *tm);
    void    (PMAPIP LZTimerOffExt)(LZTimerObject *tm);
    ulong   (PMAPIP LZTimerCountExt)(LZTimerObject *tm);
    void    (PMAPIP ULZTimerOn)(void);
    ulong   (PMAPIP ULZTimerLap)(void);
    void    (PMAPIP ULZTimerOff)(void);
    ulong   (PMAPIP ULZTimerCount)(void);
    ulong   (PMAPIP ULZReadTime)(void);
    ulong   (PMAPIP ULZElapsedTime)(ulong start,ulong finish);
    void    (PMAPIP ULZTimerResolution)(ulong *resolution);
    void *  (PMAPIP PM_findFirstFile)(const char *filename,PM_findData *findData);
    ibool   (PMAPIP PM_findNextFile)(void *handle,PM_findData *findData);
    void    (PMAPIP PM_findClose)(void *handle);
    void    (PMAPIP PM_makepath)(char *p,const char *drive,const char *dir,const char *name,const char *ext);
    int     (PMAPIP PM_splitpath)(const char *fn,char *drive,char *dir,char *name,char *ext);
    ibool   (PMAPIP PM_driveValid)(char drive);
    void    (PMAPIP PM_getdcwd)(int drive,char *dir,int len);
    void    (PMAPIP PM_setFileAttr)(const char *filename,uint attrib);
    ibool   (PMAPIP PM_mkdir)(const char *filename);
    ibool   (PMAPIP PM_rmdir)(const char *filename);
    uint    (PMAPIP PM_getFileAttr)(const char *filename);
    ibool   (PMAPIP PM_getFileTime)(const char *filename,ibool gmtTime,PM_time *time);
    ibool   (PMAPIP PM_setFileTime)(const char *filename,ibool gmtTime,PM_time *time);
    char *  (PMAPIP CPU_getProcessorName)(void);
    int     (PMAPIP PM_getVGAStateSize)(void);
    void    (PMAPIP PM_saveVGAState)(void *stateBuf);
    void    (PMAPIP PM_restoreVGAState)(const void *stateBuf);
    void    (PMAPIP PM_vgaBlankDisplay)(void);
    void    (PMAPIP PM_vgaUnblankDisplay)(void);
    void    (PMAPIP PM_blockUntilTimeout)(ulong milliseconds);
    void    (PMAPIP _PM_add64)(u32 a_low,s32 a_high,u32 b_low,s32 b_high,__i64 *result);
    void    (PMAPIP _PM_sub64)(u32 a_low,s32 a_high,u32 b_low,s32 b_high,__i64 *result);
    void    (PMAPIP _PM_mul64)(u32 a_low,s32 a_high,u32 b_low,s32 b_high,__i64 *result);
    void    (PMAPIP _PM_div64)(u32 a_low,s32 a_high,u32 b_low,s32 b_high,__i64 *result);
    void    (PMAPIP _PM_shr64)(u32 a_low,s32 a_high,s32 shift,__i64 *result);
    void    (PMAPIP _PM_sar64)(u32 a_low,s32 a_high,s32 shift,__i64 *result);
    void    (PMAPIP _PM_shl64)(u32 a_low,s32 a_high,s32 shift,__i64 *result);
    void    (PMAPIP _PM_neg64)(u32 a_low,s32 a_high,__i64 *result);
    ulong   (PMAPIP PCI_findBARSize)(int bar,PCIDeviceInfo *pci);
    void    (PMAPIP PCI_readRegBlock)(PCIDeviceInfo *info,int index,void *dst,int count);
    void    (PMAPIP PCI_writeRegBlock)(PCIDeviceInfo *info,int index,void *src,int count);
    void    (PMAPIP PM_flushTLB)(void);
    void    (PMAPIP PM_useLocalMalloc)(void * (*malloc)(size_t size),void * (*calloc)(size_t nelem,size_t size),void * (*realloc)(void *ptr,size_t size),void (*free)(void *p));
    void *  (PMAPIP PM_malloc)(size_t size);
    void *  (PMAPIP PM_calloc)(size_t nelem,size_t size);
    void *  (PMAPIP PM_realloc)(void *ptr,size_t size);
    void    (PMAPIP PM_free)(void *p);
    ibool   (PMAPIP PM_getPhysicalAddrRange)(void *p,ulong length,ulong *physAddress);
    void *  (PMAPIP PM_allocPage)(ibool locked);
    void    (PMAPIP PM_freePage)(void *p);
    ulong   (PMAPIP PM_agpInit)(void);
    void    (PMAPIP PM_agpExit)(void);
    ibool   (PMAPIP PM_agpReservePhysical)(ulong numPages,int type,void **physContext,PM_physAddr *physAddr);
    ibool   (PMAPIP PM_agpReleasePhysical)(void *physContext);
    ibool   (PMAPIP PM_agpCommitPhysical)(void *physContext,ulong numPages,ulong startOffset,PM_physAddr *physAddr);
    ibool   (PMAPIP PM_agpFreePhysical)(void *physContext,ulong numPages,ulong startOffset);
    int     (PMAPIP PCI_getNumDevices)(void);
    void    (PMAPIP PM_setLocalBPDPath)(const char *path);
    void *  (PMAPIP PM_loadDirectDraw)(int device);
    void    (PMAPIP PM_unloadDirectDraw)(int device);
    PM_HWND (PMAPIP PM_getDirectDrawWindow)(void);
    void    (PMAPIP PM_doSuspendApp)(void);
    } PM_imports;

#pragma pack()

/*---------------------------- Global variables ---------------------------*/

#ifdef  __cplusplus
extern "C" {            /* Use "C" linkage when in C++ mode */
#endif

#ifdef  __WIN32_VXD__
#define VESA_BUF_SIZE 1024
extern uchar *_PM_rmBufAddr;