pm.c

BIOS emulator and interface to Realmode X86 Emulator Library Can emulate a PCI Graphic Controller V

int PMAPI PM_int86(int intno, RMREGS *in, RMREGS *out)
{
	SWI_REGS	rmregs;

	memset(&rmregs, 0, sizeof(rmregs));
	IN(eax); IN(ebx); IN(ecx); IN(edx); IN(esi); IN(edi);

	_dx_real_int(intno,&rmregs);

	OUT(eax); OUT(ebx); OUT(ecx); OUT(edx); OUT(esi); OUT(edi);
	out->x.cflag = rmregs.flags & 0x1;
	return out->x.ax;
}

int PMAPI PM_int86x(int intno, RMREGS *in, RMREGS *out,
	RMSREGS *sregs)
{
	SWI_REGS	rmregs;

	memset(&rmregs, 0, sizeof(rmregs));
	IN(eax); IN(ebx); IN(ecx); IN(edx); IN(esi); IN(edi);
	rmregs.es = sregs->es;
	rmregs.ds = sregs->ds;

	_dx_real_int(intno,&rmregs);

	OUT(eax); OUT(ebx); OUT(ecx); OUT(edx); OUT(esi); OUT(edi);
	sregs->es = rmregs.es;
	sregs->cs = rmregs.cs;
	sregs->ss = rmregs.ss;
	sregs->ds = rmregs.ds;
	out->x.cflag = rmregs.flags & 0x1;
	return out->x.ax;
}

void PMAPI PM_availableMemory(ulong *physical,ulong *total)
{
	PMREGS 	r;
	uint	data[25];

	r.x.ax = 0x2520;				/* Get free memory info */
	r.x.bx = 0;
	r.e.edx = (uint)data;
	PM_int386(0x21, &r, &r);
	*physical = data[21] * 4096;
	*total = data[23] * 4096;
}

void *	PMAPI PM_allocLockedMem(uint size,ulong *physAddr)
{
	// Not implemented yet.
	return NULL;
}

void PMAPI PM_freeLockedMem(void *p,uint size)
{
}

#endif

/*-------------------------------------------------------------------------*/
/* Symantec C++ DOSX and FlashTek X-32/X-32VM support					   */
/*-------------------------------------------------------------------------*/

#if	defined(DOSX) || defined(X32VM)

#ifdef	X32VM
#include <x32.h>

#define	_x386_mk_protected_ptr(p)	_x32_mk_protected_ptr((void*)p)
#define	_x386_free_protected_ptr(p)	_x32_free_protected_ptr(p)
#define	_x386_zero_base_ptr			_x32_zero_base_ptr
#else
extern void *_x386_zero_base_ptr;
#endif

void * PMAPI PM_mapRealPointer(uint r_seg,uint r_off)
{
	return (void*)((ulong)_x386_zero_base_ptr + MK_PHYS(r_seg,r_off));
}

void * PMAPI PM_allocRealSeg(uint size,uint *r_seg,uint *r_off)
{
	PMREGS	r;

	r.h.ah = 0x48;					/* DOS function 48h - allocate mem	*/
	r.x.bx = (size + 0xF) >> 4;		/* Number of paragraphs to allocate	*/
	PM_int386(0x21, &r, &r);		/* Call DOS extender				*/
	if (r.x.cflag)
		return 0;					/* Could not allocate the memory	*/
	*r_seg = r.e.eax;
	*r_off = 0;
	return PM_mapRealPointer(*r_seg,*r_off);
}

void PMAPI PM_freeRealSeg(void *mem)
{
	/* Cannot de-allocate this memory */
	mem = mem;
}

#pragma pack(1)

typedef struct {
	ushort	intno;
	ushort	ds;
	ushort	es;
	ushort	fs;
	ushort	gs;
	ulong	eax;
	ulong	edx;
	} _RMREGS;

#pragma pack()

#define IN(reg)     regs.e.reg = in->e.reg
#define OUT(reg)    out->e.reg = regs.e.reg

int PMAPI PM_int86(int intno, RMREGS *in, RMREGS *out)
{
	_RMREGS rmregs;
	PMREGS  regs;
	PMSREGS	pmsregs;

	rmregs.intno = intno;
	rmregs.eax = in->e.eax;
	rmregs.edx = in->e.edx;
	IN(ebx); IN(ecx); IN(esi); IN(edi);
	regs.x.ax = 0x2511;
	regs.e.edx = (uint)(&rmregs);
	PM_segread(&pmsregs);
	PM_int386x(0x21,&regs,&regs,&pmsregs);

	OUT(eax); OUT(ebx); OUT(ecx); OUT(esi); OUT(edi);
	out->x.dx = rmregs.edx;
	out->x.cflag = regs.x.cflag;
	return out->x.ax;
}

int PMAPI PM_int86x(int intno, RMREGS *in, RMREGS *out, RMSREGS *sregs)
{
	_RMREGS rmregs;
	PMREGS  regs;
	PMSREGS	pmsregs;

	rmregs.intno = intno;
	rmregs.eax = in->e.eax;
	rmregs.edx = in->e.edx;
	rmregs.es = sregs->es;
	rmregs.ds = sregs->ds;
	IN(ebx); IN(ecx); IN(esi); IN(edi);
	regs.x.ax = 0x2511;
	regs.e.edx = (uint)(&rmregs);
	PM_segread(&pmsregs);
	PM_int386x(0x21,&regs,&regs,&pmsregs);

	OUT(eax); OUT(ebx); OUT(ecx); OUT(esi); OUT(edi);
	sregs->es = rmregs.es;
	sregs->ds = rmregs.ds;
	out->x.dx = rmregs.edx;
	out->x.cflag = regs.x.cflag;
	return out->x.ax;
}

void * PMAPI PM_getBIOSPointer(void)
{
	return (void*)((ulong)_x386_zero_base_ptr + 0x400);
}

void * PMAPI PM_getA0000Pointer(void)
{
	return (void*)((ulong)_x386_zero_base_ptr + 0xA0000);
}

void * PMAPI PM_mapPhysicalAddr(ulong base,ulong limit,ibool isCached)
{
	if (base > 0x100000)
		return _x386_map_physical_address((void*)base,limit);
	return (void*)((ulong)_x386_zero_base_ptr + base);
}

void PMAPI PM_freePhysicalAddr(void *ptr,ulong limit)
{
	/* Mapping cannot be freed */
}

ulong PMAPI PM_getPhysicalAddr(void *p)
{ return 0xFFFFFFFFUL; }

void * PMAPI PM_mapToProcess(void *base,ulong limit)
{ return (void*)base; }

ulong _cdecl _X32_getPhysMem(void);

void PMAPI PM_availableMemory(ulong *physical,ulong *total)
{
	PMREGS	regs;

	/* Get total memory available, including virtual memory */
	regs.x.ax = 0x350B;
	PM_int386(0x21,&regs,&regs);
	*total = regs.e.eax;

	/* Get physical memory available */
	*physical = _X32_getPhysMem();
	if (*physical > *total)
		*physical = *total;
}

void *	PMAPI PM_allocLockedMem(uint size,ulong *physAddr)
{
	// Not implemented yet.
	return NULL;
}

void PMAPI PM_freeLockedMem(void *p,uint size)
{
}

#endif

/*-------------------------------------------------------------------------*/
/* Borland's DPMI32, Watcom DOS4GW and DJGPP DPMI support routines		   */
/*-------------------------------------------------------------------------*/

#if	defined(DPMI32) || defined(DOS4GW) || defined(DJGPP)

void * PMAPI PM_getBIOSPointer(void)
{
	return PM_mapPhysicalAddr(0x400,0xFFFF,true);
}

void * PMAPI PM_getA0000Pointer(void)
{
	return PM_mapPhysicalAddr(0xA0000,0xFFFF,true);
}

void * PMAPI PM_mapPhysicalAddr(ulong base,ulong limit,ibool isCached)
{
#ifdef	DJGPP
	/* Enable near pointers for DJGPP V2 */
	__djgpp_nearptr_enable();
#endif
	return DPMI_mapPhysicalAddr(base,limit,isCached);
}

void PMAPI PM_freePhysicalAddr(void *ptr,ulong limit)
{
	/* Mapping cannot be freed */
	(void)ptr;
	(void)limit;
}

ulong PMAPI PM_getPhysicalAddr(void *p)
{
	/* Not implemented yet */
	(void)p;
	return 0xFFFFFFFFUL;
}

void * PMAPI PM_mapToProcess(void *base,ulong limit)
{
	(void)limit;
	return (void*)base;
}

void * PMAPI PM_mapRealPointer(uint r_seg,uint r_off)
{
	static uchar *zeroPtr = NULL;

	if (!zeroPtr)
		zeroPtr = PM_mapPhysicalAddr(0,0xFFFFF,true);
	return (void*)(zeroPtr + MK_PHYS(r_seg,r_off));
}

void * PMAPI PM_allocRealSeg(uint size,uint *r_seg,uint *r_off)
{
	PMREGS		r;
	void		*p;

	r.x.ax = 0x100;					/* DPMI allocate DOS memory			*/
	r.x.bx = (size + 0xF) >> 4;		/* number of paragraphs 			*/
	PM_int386(0x31, &r, &r);
	if (r.x.cflag)
		return NULL;				/* DPMI call failed					*/
	*r_seg = r.x.ax;				/* Real mode segment				*/
	*r_off = 0;
	p = PM_mapRealPointer(*r_seg,*r_off);
	_PM_addRealModeBlock(p,r.x.dx);
	return p;
}

void PMAPI PM_freeRealSeg(void *mem)
{
	PMREGS	r;

	r.x.ax = 0x101;						/* DPMI free DOS memory			*/
	r.x.dx = _PM_findRealModeBlock(mem);/* DX := selector from 0x100	*/
	PM_int386(0x31, &r, &r);
}

static DPMI_handler_t	DPMI_int10 = NULL;

void PMAPI DPMI_setInt10Handler(DPMI_handler_t handler)
{
	DPMI_int10 = handler;
}

void PMAPI DPMI_int86(int intno, DPMI_regs *regs)
{
	PMREGS		r;
	PMSREGS		sr;

	if (intno == 0x10 && DPMI_int10) {
		if (DPMI_int10(regs))
			return;
		}
	PM_segread(&sr);
	r.x.ax = 0x300;					/* DPMI issue real interrupt	*/
	r.h.bl = intno;
	r.h.bh = 0;
	r.x.cx = 0;
	sr.es = sr.ds;
	r.e.edi = (uint)regs;
	PM_int386x(0x31, &r, &r, &sr);	/* Issue the interrupt			*/
}

#define IN(reg)     rmregs.reg = in->e.reg
#define OUT(reg)    out->e.reg = rmregs.reg

int PMAPI PM_int86(int intno, RMREGS *in, RMREGS *out)
{
	DPMI_regs	rmregs;

	memset(&rmregs, 0, sizeof(rmregs));
	IN(eax); IN(ebx); IN(ecx); IN(edx); IN(esi); IN(edi);

	DPMI_int86(intno,&rmregs);		/* DPMI issue real interrupt	*/

	OUT(eax); OUT(ebx); OUT(ecx); OUT(edx); OUT(esi); OUT(edi);
	out->x.cflag = rmregs.flags & 0x1;
	return out->x.ax;
}

int PMAPI PM_int86x(int intno, RMREGS *in, RMREGS *out,
	RMSREGS *sregs)
{
	DPMI_regs	rmregs;

	memset(&rmregs, 0, sizeof(rmregs));
	IN(eax); IN(ebx); IN(ecx); IN(edx); IN(esi); IN(edi);
	rmregs.es = sregs->es;
	rmregs.ds = sregs->ds;

	DPMI_int86(intno,&rmregs);		/* DPMI issue real interrupt	*/

	OUT(eax); OUT(ebx); OUT(ecx); OUT(edx); OUT(esi); OUT(edi);
	sregs->es = rmregs.es;
	sregs->cs = rmregs.cs;
	sregs->ss = rmregs.ss;
	sregs->ds = rmregs.ds;
	out->x.cflag = rmregs.flags & 0x1;
	return out->x.ax;
}

#pragma pack(1)

typedef struct {
		uint	LargestBlockAvail;
		uint	MaxUnlockedPage;
		uint	LargestLockablePage;
		uint    LinAddrSpace;
		uint    NumFreePagesAvail;
		uint    NumPhysicalPagesFree;
		uint    TotalPhysicalPages;
		uint	FreeLinAddrSpace;
		uint	SizeOfPageFile;
		uint	res[3];
		} MemInfo;

#pragma pack()

void PMAPI PM_availableMemory(ulong *physical,ulong *total)
{
	PMREGS 	r;
	PMSREGS	sr;
	MemInfo	memInfo;

	PM_segread(&sr);
	r.x.ax = 0x500;					/* DPMI get free memory info */
	sr.es = sr.ds;
	r.e.edi = (uint)&memInfo;
	PM_int386x(0x31, &r, &r, &sr);	/* Issue the interrupt */
	*physical = memInfo.NumPhysicalPagesFree * 4096;
	*total = memInfo.LargestBlockAvail;
	if (*total < *physical)
		*physical = *total;
}

void *	PMAPI PM_allocLockedMem(uint size,ulong *physAddr)
{
	/* Not implemented yet */
	(void)size;
	(void)physAddr;
	return NULL;
}

void PMAPI PM_freeLockedMem(void *p,uint size)
{
	(void)p;
	(void)size;
}

#endif

#ifndef	__16BIT__

/****************************************************************************
REMARKS:
Call the VBE/Core software interrupt to change display banks.
****************************************************************************/
void PMAPI PM_setBankA(
	int bank)
{
	DPMI_regs	regs;
	memset(&regs, 0, sizeof(regs));
	regs.eax = 0x4F05;
	regs.ebx = 0x0000;
	regs.edx = bank;
	DPMI_int86(0x10,&regs);
}

/****************************************************************************
REMARKS:
Call the VBE/Core software interrupt to change display banks.
****************************************************************************/
void PMAPI PM_setBankAB(
	int bank)
{
	DPMI_regs	regs;
	memset(&regs, 0, sizeof(regs));
	regs.eax = 0x4F05;
	regs.ebx = 0x0000;
	regs.edx = bank;
	DPMI_int86(0x10,&regs);
	regs.eax = 0x4F05;
	regs.ebx = 0x0001;
	regs.edx = bank;
	DPMI_int86(0x10,&regs);
}

/****************************************************************************
REMARKS:
Call the VBE/Core software interrupt to change display start address.
****************************************************************************/
void PMAPI PM_setCRTStart(
	int x,
	int y,
	int waitVRT)
{
	DPMI_regs	regs;
	memset(&regs, 0, sizeof(regs));
	regs.eax = 0x4F07;
	regs.ebx = waitVRT;
	regs.ecx = x;
	regs.edx = y;
	DPMI_int86(0x10,&regs);
}

#endif