pm.c

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

REMARKS:
Free a block of real mode memory.
****************************************************************************/
void PMAPI PM_freeRealSeg(
	void *mem)
{
	/* Nothing to do in here */
	(void)mem;
}

#define INDPMI(reg)     rmregs.aCRF.reg_##reg = regs->reg
#define OUTDPMI(reg)    regs->reg = rmregs.aCRF.reg_##reg

#define REG_OFFSET(field)  (((ULONG)&(((VCRF*)0)->field))  / sizeof(ULONG))

/****************************************************************************
REMARKS:
Issue a real mode interrupt (parameters in DPMI compatible structure)
****************************************************************************/
void PMAPI DPMI_int86(
	int intno,
	DPMI_regs *regs)
{
	INTCRF	rmregs;
	ulong	eax;

	if (!InitInt10())
		return;
	memset(&rmregs, 0, sizeof(rmregs));
	rmregs.ulBIOSIntNo = intno;
	INDPMI(eax); INDPMI(ebx); INDPMI(ecx); INDPMI(edx); INDPMI(esi); INDPMI(edi);
	rmregs.aCRF.reg_ds = regs->ds;
	rmregs.aCRF.reg_es = regs->es;
	if (intno == 0x10) {
		eax = rmregs.aCRF.reg_eax;
		switch (eax & 0xFFFF) {
			case 0x4F00:
				rmregs.pB[0].bBufferType = INPUT_BUFFER;
				rmregs.pB[0].bSelCRF = REG_OFFSET(reg_es);
				rmregs.pB[0].bOffCRF = REG_OFFSET(reg_edi);
				rmregs.pB[0].pAddress = RMBuf;
				rmregs.pB[0].ulSize = 4;
				rmregs.pB[1].bBufferType = OUTPUT_BUFFER;
				rmregs.pB[1].bSelCRF = REG_OFFSET(reg_es);
				rmregs.pB[1].bOffCRF = REG_OFFSET(reg_edi);
				rmregs.pB[1].pAddress = RMBuf;
				rmregs.pB[1].ulSize = 512;
				break;
			case 0x4F01:
				rmregs.pB[0].bBufferType = OUTPUT_BUFFER;
				rmregs.pB[0].bSelCRF = REG_OFFSET(reg_es);
				rmregs.pB[0].bOffCRF = REG_OFFSET(reg_edi);
				rmregs.pB[0].pAddress = RMBuf;
				rmregs.pB[0].ulSize = 256;
				break;
			case 0x4F09:
				rmregs.pB[0].bBufferType = INPUT_BUFFER;
				rmregs.pB[0].bSelCRF = REG_OFFSET(reg_es);
				rmregs.pB[0].bOffCRF = REG_OFFSET(reg_edi);
				rmregs.pB[0].pAddress = RMBuf;
				rmregs.pB[0].ulSize = 1024;
				break;
			}
		}
	PM_VIDEOPMI32Request(&Adapter,PMIREQUEST_SOFTWAREINT,NULL,&rmregs);
	OUTDPMI(eax); OUTDPMI(ebx); OUTDPMI(ecx); OUTDPMI(edx); OUTDPMI(esi); OUTDPMI(edi);
	regs->ds = rmregs.aCRF.reg_ds;
	regs->es = rmregs.aCRF.reg_es;
	regs->flags = rmregs.aCRF.reg_eflag;
}

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

/****************************************************************************
REMARKS:
Issue a real mode interrupt.
****************************************************************************/
int PMAPI PM_int86(
	int intno,
	RMREGS *in,
	RMREGS *out)
{
	DPMI_regs	rmregs;

	if (!InitInt10())
		return 0;
	memset(&rmregs, 0, sizeof(rmregs));
	IN(eax); IN(ebx); IN(ecx); IN(edx); IN(esi); IN(edi);
	DPMI_int86(intno,&rmregs);
	OUT(eax); OUT(ebx); OUT(ecx); OUT(edx); OUT(esi); OUT(edi);
	out->x.cflag = rmregs.flags & 0x1;
	return out->x.ax;
}

/****************************************************************************
REMARKS:
Issue a real mode interrupt.
****************************************************************************/
int PMAPI PM_int86x(
	int intno,
	RMREGS *in,
	RMREGS *out,
	RMSREGS *sregs)
{
	DPMI_regs	rmregs;

	if (!InitInt10())
		return 0;
	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);
	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;
}

/****************************************************************************
REMARKS:
Call a real mode far function.
****************************************************************************/
void PMAPI PM_callRealMode(
	uint seg,
	uint off,
	RMREGS *in,
	RMSREGS *sregs)
{
	PM_fatalError("PM_callRealMode not supported on OS/2!");
}

/****************************************************************************
REMARKS:
Return the amount of available memory.
****************************************************************************/
void PMAPI PM_availableMemory(
	ulong *physical,
	ulong *total)
{
	/* Unable to get reliable values from OS/2 for this */
	*physical = *total = 0;
}

/****************************************************************************
REMARKS:
Allocate a block of locked, physical memory for DMA operations.
****************************************************************************/
void * PMAPI PM_allocLockedMem(
	uint size,
	ulong *physAddr)
{
	parmsIn[0] = size;
	CallSDDHelp(PMHELP_ALLOCLOCKED);
	*physAddr = parmsOut[1];
	return (void*)parmsOut[0];
}

/****************************************************************************
REMARKS:
Free a block of locked physical memory.
****************************************************************************/
void PMAPI PM_freeLockedMem(
	void *p,
	uint size)
{
	parmsIn[0] = (ulong)p;
	CallSDDHelp(PMHELP_FREELOCKED);
}

/****************************************************************************
REMARKS:
Lock linear memory so it won't be paged.
****************************************************************************/
int PMAPI PM_lockDataPages(
	void *p,
	uint len)
{
	/* TODO: Implement this for OS/2 */
	(void)p;
	(void)len;
	return 0;
}

/****************************************************************************
REMARKS:
Unlock linear memory so it won't be paged.
****************************************************************************/
int PMAPI PM_unlockDataPages(
	void *p,
	uint len)
{
	/* TODO: Implement this for OS/2 */
	(void)p;
	(void)len;
	return 0;
}

/****************************************************************************
REMARKS:
Lock linear memory so it won't be paged.
****************************************************************************/
int PMAPI PM_lockCodePages(
	void (*p)(),
	uint len)
{
	/* TODO: Implement this for OS/2 */
	(void)p;
	(void)len;
	return 0;
}

/****************************************************************************
REMARKS:
Unlock linear memory so it won't be paged.
****************************************************************************/
int PMAPI PM_unlockCodePages(
	void (*p)(),
	uint len)
{
	/* TODO: Implement this for OS/2 */
	(void)p;
	(void)len;
	return 0;
}

/****************************************************************************
REMARKS:
Call the VBE/Core software interrupt to change display banks.
****************************************************************************/
void PMAPI PM_setBankA(
	int bank)
{
	INTCRF	rmregs;

	if (!InitInt10())
		return;
	memset(&rmregs, 0, sizeof(rmregs));
	rmregs.ulBIOSIntNo = 0x10;
	rmregs.aCRF.reg_eax = 0x4F05;
	rmregs.aCRF.reg_ebx = 0x0000;
	rmregs.aCRF.reg_edx = bank;
	PM_VIDEOPMI32Request(&Adapter,PMIREQUEST_SOFTWAREINT,&rmregs,NULL);
}

/****************************************************************************
REMARKS:
Call the VBE/Core software interrupt to change display banks.
****************************************************************************/
void PMAPI PM_setBankAB(
	int bank)
{
	INTCRF	rmregs;

	if (!InitInt10())
		return;
	memset(&rmregs, 0, sizeof(rmregs));
	rmregs.ulBIOSIntNo = 0x10;
	rmregs.aCRF.reg_eax = 0x4F05;
	rmregs.aCRF.reg_ebx = 0x0000;
	rmregs.aCRF.reg_edx = bank;
	PM_VIDEOPMI32Request(&Adapter,PMIREQUEST_SOFTWAREINT,&rmregs,NULL);
	rmregs.ulBIOSIntNo = 0x10;
	rmregs.aCRF.reg_eax = 0x4F05;
	rmregs.aCRF.reg_ebx = 0x0001;
	rmregs.aCRF.reg_edx = bank;
	PM_VIDEOPMI32Request(&Adapter,PMIREQUEST_SOFTWAREINT,&rmregs,NULL);
}

/****************************************************************************
REMARKS:
Call the VBE/Core software interrupt to change display start address.
****************************************************************************/
void PMAPI PM_setCRTStart(
	int x,
	int y,
	int waitVRT)
{
	INTCRF	rmregs;

	if (!InitInt10())
		return;
	memset(&rmregs, 0, sizeof(rmregs));
	rmregs.ulBIOSIntNo = 0x10;
	rmregs.aCRF.reg_eax = 0x4F07;
	rmregs.aCRF.reg_ebx = waitVRT;
	rmregs.aCRF.reg_ecx = x;
	rmregs.aCRF.reg_edx = y;
	PM_VIDEOPMI32Request(&Adapter,PMIREQUEST_SOFTWAREINT,&rmregs,NULL);
}

#define	GetRMVect(intno,isr)	*(isr) = ((ulong*)rmZeroPtr)[intno]
#define	SetRMVect(intno,isr)	((ulong*)rmZeroPtr)[intno] = (isr)

/****************************************************************************
REMARKS:
Execute the POST on the secondary BIOS for a controller.
****************************************************************************/
ibool PMAPI PM_doBIOSPOST(
	ushort axVal,
	ulong BIOSPhysAddr,
	void *mappedBIOS)
{
	(void)axVal;
	(void)BIOSPhysAddr;
	(void)mappedBIOS;
	return false;
}

/* MTRR helper functions. To make it easier to implement the MTRR support
 * under OS/2, we simply put our ring 0 helper functions into the
 * helper device driver rather than the entire MTRR module. This makes
 * it easier to maintain the MTRR support since we don't need to deal
 * with 16-bit ring 0 code in the MTRR library.
 */

/****************************************************************************
REMARKS:
Return true if ring 0 (or if we can call the helpers functions at ring 0)
****************************************************************************/
ibool _ASMAPI _MTRR_isRing0(void)
{
	return true;
}

/****************************************************************************
REMARKS:
Flush the translation lookaside buffer.
****************************************************************************/
void _ASMAPI _MTRR_flushTLB(void)
{
	CallSDDHelp(PMHELP_FLUSHTLB);
}

/****************************************************************************
REMARKS:
Read and return the value of the CR4 register
****************************************************************************/
ulong _ASMAPI _MTRR_saveCR4(void)
{
	return CallSDDHelp(PMHELP_SAVECR4);
}

/****************************************************************************
REMARKS:
Restore the value of the CR4 register
****************************************************************************/
void _ASMAPI _MTRR_restoreCR4(ulong cr4Val)
{
	parmsIn[0] = cr4Val;
	CallSDDHelp(PMHELP_RESTORECR4);
}

/****************************************************************************
REMARKS:
Read a machine status register for the CPU.
****************************************************************************/
void _ASMAPI _MTRR_readMSR(
	int reg,
	ulong *eax,
	ulong *edx)
{
	parmsIn[0] = reg;
	CallSDDHelp(PMHELP_READMSR);
	*eax = parmsOut[0];
	*edx = parmsOut[1];
}

/****************************************************************************
REMARKS:
Write a machine status register for the CPU.
****************************************************************************/
void _ASMAPI _MTRR_writeMSR(
	int reg,
	ulong eax,
	ulong edx)
{
	parmsIn[0] = reg;
	parmsIn[1] = eax;
	parmsIn[2] = edx;
	CallSDDHelp(PMHELP_WRITEMSR);
}

PM_MODULE PMAPI PM_loadLibrary(
	const char *szDLLName)
{
	// TODO: Implement this to load shared libraries!
	(void)szDLLName;
	return NULL;
}

void * PMAPI PM_getProcAddress(
	PM_MODULE hModule,
	const char *szProcName)
{
	// TODO: Implement this!
	(void)hModule;
	(void)szProcName;
	return NULL;
}

void PMAPI PM_freeLibrary(
	PM_MODULE hModule)
{
	// TODO: Implement this!
	(void)hModule;
}