/*---------------------------------------------------------------------------- 
COPYRIGHT (c) 1995 by Philips Semiconductors

THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED AND COPIED IN 
ACCORDANCE WITH THE TERMS AND CONDITIONS OF SUCH A LICENSE AND WITH THE 
INCLUSION OF THE THIS COPY RIGHT NOTICE. THIS SOFTWARE OR ANY OTHER COPIES 
OF THIS SOFTWARE MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY OTHER
PERSON. THE OWNERSHIP AND TITLE OF THIS SOFTWARE IS NOT TRANSFERRED. 

THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT ANY PRIOR NOTICE
AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY Philips Semiconductor. 

PHILIPS ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF THIS SOFTWARE
ON PLATFORMS OTHER THAN THE ONE ON WHICH THIS SOFTWARE IS FURNISHED.
----------------------------------------------------------------------------*/

/*
ABSTRACT

HISTROY
	#define	TR	Tilakraj Roy
	950326	TR 	Created	

*/

#ifndef	_VXWIN_H_
#define	_VXWIN_H_

typedef struct _LINADDR
{
	DWORD	PageOffset		:12;
	DWORD	PageNumber		:10;
	DWORD	PageDirectory	:10;
}	LINADDR, *PLINADDR;

typedef	struct	_WINIOSTRUCT
{
	struct VxD_IOT_Hdr	IOHeader;
	struct VxD_IO_Struc	IOStruct;
}	WINIOSTRUCT,	*PWINIOSTRUCT;

typedef	struct VID	WINVID, *PWINVID;

typedef struct _PTE 
{
    DWORD   dwPhysAddr;
    DWORD   dwSize;
} PTE, *PPTE;

typedef struct _EDDS
{
    DWORD   dwSize;
    DWORD   dwLinear;
    WORD    wSegment;
    WORD    wReserved;
    WORD    wAvailable;
    WORD    wUsed;
	PTE		PageTable[1];
}   EDDS, *PEDDS;
	

STATUS	winAllocate_Device_CB_Area ( WORD wSizeToAlocate, 
		PDWORD pwDeviceCBOffset );
STATUS	winDeallocate_Device_CB_Area ( DWORD dwDeviceOffset);

STATUS	winAllocate_GDT_Selector ( DWORD dwDescHi, DWORD dwDescLo,
		PWORD pSelector );
STATUS	winFree_GDT_Selector ( WORD wSelector );

DWORD	winPageAllocate(DWORD dwPages, DWORD dwType, DWORD dwVM,
	DWORD dwAlignMask, DWORD dwMinPages, DWORD dwMaxPages, PDWORD pdwPhysAddx,
	DWORD dwFlags, PDWORD pdwHandle );

/*
STATUS	winPageAllocate ( DWORD dwAlignment, DWORD dwPages, PDWORD pHandle,
		PDWORD pPhysAddx, PDWORD pLength, PDWORD pLinearAddx);
*/

STATUS	winPageFree ( DWORD dwHandle );

STATUS	winBuildDescriptorDWORDS ( DWORD dwLinearAddx, DWORD dwLength,
	PDWORD pDescHi, PDWORD pDescLo );

STATUS	winHook_V86_Int_Chain(BYTE bInterruptNumber, PVOID pFunction);
STATUS	winUnhook_V86_Int_Chain(BYTE bInterruptNumber);
STATUS	winMult_IO_Handlers(PWINIOSTRUCT pVxDIoStruct);

STATUS	winInstall_IO_Handler(WORD wPort, DWORD dwCallback);
STATUS	winRemove_IO_Handler ( WORD wPort );

STATUS	winTest_Sys_VM_Handle(DWORD dwVMHandle);
DWORD	winGet_Sys_VM_Handle(VOID);
DWORD	winGet_Cur_VM_Handle(VOID);
DWORD	winMapPhysToLinear ( DWORD dwPhysAddress, DWORD dwBytes, DWORD flags );
DWORD	winSelectorMapFlat ( DWORD dwVMHandle, DWORD dwSelector, DWORD dwFlags);

DWORD	winVPICD_Virtualize_IRQ(PWINVID pIRQDescriptors);
STATUS	winVPICD_Convert_Handle_To_IRQ(DWORD dwIRQHandle, PBYTE pbIrqNumber);
STATUS	winVPICD_Set_Int_Request(DWORD dwVMHandle, DWORD dwIRQHandle);
STATUS	winVPICD_Clear_Int_Request(DWORD dwVMHandle, DWORD dwIRQHandle);
STATUS	winVPICD_Physically_Mask(DWORD dwIRQHandle);
STATUS	winVPICD_Physically_Unmask(DWORD dwIRQHandle);
STATUS	winVPICD_Set_Auto_Masking(DWORD dwIRQHandle);
STATUS	winVPICD_Force_Default_Behavior(DWORD dwIRQHandle);
STATUS	winVPICD_Phys_EOI(DWORD dwIRQHandle);
STATUS	winVPICD_Get_Complete_Status(DWORD dwIRQHandle, DWORD dwVmHandle,
		PDWORD pdwStatus);

STATUS	winEnable_Local_Trapping(DWORD dwVMHandle, WORD wPort);
STATUS	winDisable_Local_Trapping(DWORD dwVMHandle, WORD wPort);

STATUS	winGet_Profile_String(PBYTE lpszSeciton, PBYTE lpszKey,
		PBYTE *pResult);
STATUS	winGet_Profile_Boolean(PBYTE lpszSeciton, PBYTE lpszKey,
		PDWORD pResult);
STATUS	winGet_Profile_Decimal_Int(PBYTE lpszSeciton, PBYTE lpszKey,
		PDWORD pResult);
BOOL	winGet_Profile_Hex_Int(PBYTE lpszSeciton, PBYTE lpszKey,
		PDWORD pResult);
STATUS	winGet_VMM_Version(PWORD pwVersion);

STATUS	winVDMAD_Default_Handler(DWORD dwDMAHandle, DWORD dwVMHAndle);
STATUS	winVDMAD_Disable_Translation(DWORD dwDMAHandle, DWORD dwVMHAndle);
STATUS	winVDMAD_Enable_Translation(DWORD dwDMAHandle, DWORD dwVMHAndle);
STATUS	winVDMAD_Virtualize_Channel(BYTE bChannel, DWORD dwCallback,
		PDWORD pHandle);
STATUS	winVDMAD_Unvirtualize_Channel(DWORD dwDMAHandle);
STATUS	winVDMAD_Set_Region_Info(DWORD dwDMAHandle, DWORD dwLinear,
		DWORD dwSize, DWORD dwPhysical);
STATUS	winVDMAD_Set_Phys_State(DWORD dwDMAHandle, DWORD dwVMHandle,
		BYTE bMode);
STATUS	winVDMAD_Unmask_Channel(DWORD dwDMAHandle, DWORD dwVMHandle);
STATUS	winVDMAD_Phys_Unmask_Channel(DWORD dwDMAHandle, DWORD dwVMHandle);
STATUS	winVDMAD_Mask_Channel(DWORD dwDMAHandle, DWORD dwVMHandle);
STATUS	winVDMAD_Get_Virt_State(DWORD dwDMAHandle, DWORD dwVMHandle,
		PDWORD pdwBuffer, PDWORD pdwCount, PBYTE pbMode);
STATUS	winVDMAD_Set_Virt_State(DWORD dwDMAHandle, DWORD dwVMHandle,
		DWORD dwBuffer, DWORD dwCount, BYTE bMode);
STATUS  winVDMAD_Phys_Mask_Channel(DWORD dwDMAHandle, DWORD dwVMHandle);
STATUS  winVDMAD_Get_Cur_Count(DWORD dwDMAHandle, DWORD dwVMHandle, 
		DWORD lpwCount);
STATUS	winVDMAD_Scatter_Lock ( DWORD dwVM, BYTE bFlags, PEDDS pEDDS );
STATUS	winVDMAD_Scatter_Unlock ( DWORD dwVM, BYTE bFlags, PEDDS pEDDS );

STATUS	winList_Allocate ( DWORD dwListHandle, PDWORD pNode);
STATUS	winList_Attach_Tail ( DWORD dwListHandle, DWORD dwNode);
STATUS	winList_Create ( DWORD dwNodeSize, PDWORD pNode);
STATUS	winList_Destroy ( DWORD dwListHandle );
STATUS	winList_Get_First ( DWORD dwListHandle, PDWORD pNode);
STATUS	winList_Get_Next ( DWORD dwListHandle, PDWORD pNode);
STATUS	winList_Deallocate ( DWORD dwListHandle, DWORD dwNode);
STATUS	winList_Remove ( DWORD dwListHandle, DWORD dwNode);

PVOID	winHeapAllocate ( DWORD dwSize );
STATUS	winHeapFree ( DWORD dwAddress );

STATUS	winHook_Device_Service ( PVOID  pfCallback );
STATUS	winUnhook_Device_Service ( PVOID pfCallback );

/* PCI related functions */

BOOL pciCheckBIOS ( 
	PBYTE	pbLastBus,
	PBYTE	pbMajorVersion, 
	PBYTE	pbMinorVersion );

BOOL pciFindDevice ( WORD wDeviceID, WORD wVendorID, WORD wIndex, 
	PBYTE pbBus, PBYTE pbDevFunc );
BOOL pciFindClass ( DWORD dwClass, WORD wIndex, PBYTE pbBus, 
		PBYTE pbDevFunc );
BOOL pciReadConfigDW ( BYTE bBus, BYTE bDevFunc, WORD wRegNum, 
	PDWORD pdwValue);
BOOL pciWriteConfigDW ( BYTE bBus, BYTE bDevFunc, WORD wRegNum, 
	DWORD dwValue);

BOOL winSchedule_Global_Event ( VOID (*pFunc)(VOID),
	PVOID pvCallbackContext, PDWORD pdwEventHandle );

BOOL winSchedule_VM_Event ( DWORD VMHandle, VOID (*pFunc)(VOID),
	PVOID pvCallbackContext, PDWORD pdwEventHandle );

BOOL winCall_Priority_VM_Event ( 
	DWORD dwPriorityBoost,
	DWORD dwVMHandle,
	DWORD dwFlags,
	PVOID pvCallbackContext,
	VOID (*pFunc)(VOID), 
	DWORD dwTimeOut,
	PDWORD pdwEventHandle );

BOOL winCancel_Priority_VM_Event ( DWORD dwEventHandle );
/* VWIN32 functions */

VOID winVWIN32_DIOCCompletionRoutine ( DWORD dwEvent );
DWORD winVWIN32_PulseWin32Event ( DWORD dwEvent );
DWORD winVWIN32_SetWin32Event ( DWORD dwEvent );
VOID winVWIN32_CloseVxDHandle ( DWORD dwHandle );

DWORD winVWIN32_GetCurrentProcessHandle ( VOID );
DWORD winVWIN32_SysErrorBox ( PVOID pVSEB );
/* functions for debugging */

VOID	winIn_Debug_Chr ( PBYTE pbInput );

/* Scatter Gather Lock Functions */

BOOL	sgBufferLock ( PVOID pBuffer, DWORD dwSize, PVOID *ppEDDS );
BOOL	sgBufferUnlock( PVOID pvEDDS );

VOID	winStallProcessorExecution ( DWORD TimeInMicroSeconds );
#endif // _VXWIN_H_