[people/ms/u-boot.git] / drivers / bios_emulator / biosemu.c

/****************************************************************************
*
*			 BIOS emulator and interface
*		       to Realmode X86 Emulator Library
*
*  Copyright (C) 2007 Freescale Semiconductor, Inc.
*  Jason Jin <Jason.jin@freescale.com>
*
*		Copyright (C) 1996-1999 SciTech Software, Inc.
*
*  ========================================================================
*
*  Permission to use, copy, modify, distribute, and sell this software and
*  its documentation for any purpose is hereby granted without fee,
*  provided that the above copyright notice appear in all copies and that
*  both that copyright notice and this permission notice appear in
*  supporting documentation, and that the name of the authors not be used
*  in advertising or publicity pertaining to distribution of the software
*  without specific, written prior permission.	The authors makes no
*  representations about the suitability of this software for any purpose.
*  It is provided "as is" without express or implied warranty.
*
*  THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
*  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
*  EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
*  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
*  USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
*  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
*  PERFORMANCE OF THIS SOFTWARE.
*
*  ========================================================================
*
* Language:	ANSI C
* Environment:	Any
* Developer:	Kendall Bennett
*
* Description:	Module implementing the system specific functions. This
*		module is always compiled and linked in the OS depedent
*		libraries, and never in a binary portable driver.
*
*		Jason ported this file to u-boot to run the ATI video card BIOS
*		in u-boot. Made all the video memory be emulated during the
*		BIOS runing process which may affect the VGA function but the
*		frambuffer function can work after run the BIOS.
*
****************************************************************************/

#include <malloc.h>
#include <common.h>
#include "biosemui.h"

BE_sysEnv _BE_env = {{0}};
static X86EMU_memFuncs _BE_mem __attribute__((section(GOT2_TYPE))) = {
	BE_rdb,
	BE_rdw,
	BE_rdl,
	BE_wrb,
	BE_wrw,
	BE_wrl,
	};

static X86EMU_pioFuncs _BE_pio __attribute__((section(GOT2_TYPE))) = {
	BE_inb,
	BE_inw,
	BE_inl,
	BE_outb,
	BE_outw,
	BE_outl,
	};

#define OFF(addr)	(u16)(((addr) >> 0) & 0xffff)
#define SEG(addr)	(u16)(((addr) >> 4) & 0xf000)

/****************************************************************************
PARAMETERS:
debugFlags  - Flags to enable debugging options (debug builds only)
memSize	    - Amount of memory to allocate for real mode machine
info	    - Pointer to default VGA device information

REMARKS:
This functions initialises the BElib, and uses the passed in
BIOS image as the BIOS that is used and emulated at 0xC0000.
****************************************************************************/
int X86API BE_init(u32 debugFlags, int memSize, BE_VGAInfo * info, int shared)
{
#if !defined(__DRIVER__)  && !defined(__KERNEL__)

	PM_init();
#endif
	memset(&M, 0, sizeof(M));
	if (memSize < 20480){
		printf("Emulator requires at least 20Kb of memory!\n");
		return 0;
	}

	M.mem_base = malloc(memSize);

	if (M.mem_base == NULL){
		printf("Biosemu:Out of memory!");
		return 0;
	}
	M.mem_size = memSize;

	_BE_env.emulateVGA = 0;
	_BE_env.busmem_base = (unsigned long)malloc(128 * 1024);
	if ((void *)_BE_env.busmem_base == NULL){
		printf("Biosemu:Out of memory!");
		return 0;
	}
	M.x86.debug = debugFlags;
	_BE_bios_init((u32*)info->LowMem);
	X86EMU_setupMemFuncs(&_BE_mem);
	X86EMU_setupPioFuncs(&_BE_pio);
	BE_setVGA(info);
	return 1;
}

/****************************************************************************
PARAMETERS:
info	    - Pointer to VGA device information to make current

REMARKS:
This function sets the VGA BIOS functions in the emulator to point to the
specific VGA BIOS in use. This includes swapping the BIOS interrupt
vectors, BIOS image and BIOS data area to the new BIOS. This allows the
real mode BIOS to be swapped without resetting the entire emulator.
****************************************************************************/
void X86API BE_setVGA(BE_VGAInfo * info)
{

#ifdef __KERNEL__
	_BE_env.vgaInfo.function = info->function;
	_BE_env.vgaInfo.device = info->device;
	_BE_env.vgaInfo.bus = info->bus;
	_BE_env.vgaInfo.pcidev = info->pcidev;
#else
	_BE_env.vgaInfo.pciInfo = info->pciInfo;
#endif
	_BE_env.vgaInfo.BIOSImage = info->BIOSImage;
	if (info->BIOSImage) {
		_BE_env.biosmem_base = (ulong) info->BIOSImage;
		_BE_env.biosmem_limit = 0xC0000 + info->BIOSImageLen - 1;
	} else {
		_BE_env.biosmem_base = _BE_env.busmem_base + 0x20000;
		_BE_env.biosmem_limit = 0xC7FFF;
	}
	if ((info->LowMem[0] == 0) && (info->LowMem[1] == 0) &&
	    (info->LowMem[2] == 0) && (info->LowMem[3] == 0))
		_BE_bios_init((u32 *) info->LowMem);
	memcpy((u8 *) M.mem_base, info->LowMem, sizeof(info->LowMem));
}

/****************************************************************************
PARAMETERS:
info	    - Pointer to VGA device information to retrieve current

REMARKS:
This function returns the VGA BIOS functions currently active in the
emulator, so they can be restored at a later date.
****************************************************************************/
void X86API BE_getVGA(BE_VGAInfo * info)
{
#ifdef __KERNEL__
	info->function = _BE_env.vgaInfo.function;
	info->device = _BE_env.vgaInfo.device;
	info->bus = _BE_env.vgaInfo.bus;
	info->pcidev = _BE_env.vgaInfo.pcidev;
#else
	info->pciInfo = _BE_env.vgaInfo.pciInfo;
#endif
	info->BIOSImage = _BE_env.vgaInfo.BIOSImage;
	memcpy(info->LowMem, (u8 *) M.mem_base, sizeof(info->LowMem));
}

/****************************************************************************
PARAMETERS:
r_seg	- Segment for pointer to convert
r_off	- Offset for pointer to convert

REMARKS:
This function maps a real mode pointer in the emulator memory to a protected
mode pointer that can be used to directly access the memory.

NOTE:	The memory is *always* in little endian format, son on non-x86
	systems you will need to do endian translations to access this
	memory.
****************************************************************************/
void *X86API BE_mapRealPointer(uint r_seg, uint r_off)
{
	u32 addr = ((u32) r_seg << 4) + r_off;

	if (addr >= 0xC0000 && addr <= _BE_env.biosmem_limit) {
		return (void *)(_BE_env.biosmem_base + addr - 0xC0000);
	} else if (addr >= 0xA0000 && addr <= 0xFFFFF) {
		return (void *)(_BE_env.busmem_base + addr - 0xA0000);
	}
	return (void *)(M.mem_base + addr);
}

/****************************************************************************
PARAMETERS:
len	- Return the length of the VESA buffer
rseg	- Place to store VESA buffer segment
roff	- Place to store VESA buffer offset

REMARKS:
This function returns the address of the VESA transfer buffer in real
_BE_piomode emulator memory. The VESA transfer buffer is always 1024 bytes long,
and located at 15Kb into the start of the real mode memory (16Kb is where
we put the real mode code we execute for issuing interrupts).

NOTE:	The memory is *always* in little endian format, son on non-x86
	systems you will need to do endian translations to access this
	memory.
****************************************************************************/
void *X86API BE_getVESABuf(uint * len, uint * rseg, uint * roff)
{
	*len = 1024;
	*rseg = SEG(0x03C00);
	*roff = OFF(0x03C00);
	return (void *)(M.mem_base + ((u32) * rseg << 4) + *roff);
}

/****************************************************************************
REMARKS:
Cleans up and exits the emulator.
****************************************************************************/
void X86API BE_exit(void)
{
	free(M.mem_base);
	free((void *)_BE_env.busmem_base);
}

/****************************************************************************
PARAMETERS:
seg	- Segment of code to call
off	- Offset of code to call
regs	- Real mode registers to load
sregs	- Real mode segment registers to load

REMARKS:
This functions calls a real mode far function at the specified address,
and loads all the x86 registers from the passed in registers structure.
On exit the registers returned from the call are returned in the same
structures.
****************************************************************************/
void X86API BE_callRealMode(uint seg, uint off, RMREGS * regs, RMSREGS * sregs)
{
	M.x86.R_EAX = regs->e.eax;
	M.x86.R_EBX = regs->e.ebx;
	M.x86.R_ECX = regs->e.ecx;
	M.x86.R_EDX = regs->e.edx;
	M.x86.R_ESI = regs->e.esi;
	M.x86.R_EDI = regs->e.edi;
	M.x86.R_DS = sregs->ds;
	M.x86.R_ES = sregs->es;
	M.x86.R_FS = sregs->fs;
	M.x86.R_GS = sregs->gs;

	((u8 *) M.mem_base)[0x4000] = 0x9A;
	((u8 *) M.mem_base)[0x4001] = (u8) off;
	((u8 *) M.mem_base)[0x4002] = (u8) (off >> 8);
	((u8 *) M.mem_base)[0x4003] = (u8) seg;
	((u8 *) M.mem_base)[0x4004] = (u8) (seg >> 8);
	((u8 *) M.mem_base)[0x4005] = 0xF1;	/* Illegal op-code */
	M.x86.R_CS = SEG(0x04000);
	M.x86.R_IP = OFF(0x04000);

	M.x86.R_SS = SEG(M.mem_size - 2);
	M.x86.R_SP = OFF(M.mem_size - 2) + 2;

	X86EMU_exec();

	regs->e.cflag = M.x86.R_EFLG & F_CF;
	regs->e.eax = M.x86.R_EAX;
	regs->e.ebx = M.x86.R_EBX;
	regs->e.ecx = M.x86.R_ECX;
	regs->e.edx = M.x86.R_EDX;
	regs->e.esi = M.x86.R_ESI;
	regs->e.edi = M.x86.R_EDI;
	sregs->ds = M.x86.R_DS;
	sregs->es = M.x86.R_ES;
	sregs->fs = M.x86.R_FS;
	sregs->gs = M.x86.R_GS;
}

/****************************************************************************
PARAMETERS:
intno	- Interrupt number to execute
in	- Real mode registers to load
out	- Place to store resulting real mode registers

REMARKS:
This functions calls a real mode interrupt function at the specified address,
and loads all the x86 registers from the passed in registers structure.
On exit the registers returned from the call are returned in out stucture.
****************************************************************************/
int X86API BE_int86(int intno, RMREGS * in, RMREGS * out)
{
	M.x86.R_EAX = in->e.eax;
	M.x86.R_EBX = in->e.ebx;
	M.x86.R_ECX = in->e.ecx;
	M.x86.R_EDX = in->e.edx;
	M.x86.R_ESI = in->e.esi;
	M.x86.R_EDI = in->e.edi;
	((u8 *) M.mem_base)[0x4000] = 0xCD;
	((u8 *) M.mem_base)[0x4001] = (u8) intno;
	((u8 *) M.mem_base)[0x4002] = 0xF1;
	M.x86.R_CS = SEG(0x04000);
	M.x86.R_IP = OFF(0x04000);

	M.x86.R_SS = SEG(M.mem_size - 1);
	M.x86.R_SP = OFF(M.mem_size - 1) - 1;

	X86EMU_exec();
	out->e.cflag = M.x86.R_EFLG & F_CF;
	out->e.eax = M.x86.R_EAX;
	out->e.ebx = M.x86.R_EBX;
	out->e.ecx = M.x86.R_ECX;
	out->e.edx = M.x86.R_EDX;
	out->e.esi = M.x86.R_ESI;
	out->e.edi = M.x86.R_EDI;
	return out->x.ax;
}

/****************************************************************************
PARAMETERS:
intno	- Interrupt number to execute
in	- Real mode registers to load
out	- Place to store resulting real mode registers
sregs	- Real mode segment registers to load

REMARKS:
This functions calls a real mode interrupt function at the specified address,
and loads all the x86 registers from the passed in registers structure.
On exit the registers returned from the call are returned in out stucture.
****************************************************************************/
int X86API BE_int86x(int intno, RMREGS * in, RMREGS * out, RMSREGS * sregs)
{
	M.x86.R_EAX = in->e.eax;
	M.x86.R_EBX = in->e.ebx;
	M.x86.R_ECX = in->e.ecx;
	M.x86.R_EDX = in->e.edx;
	M.x86.R_ESI = in->e.esi;
	M.x86.R_EDI = in->e.edi;
	M.x86.R_DS = sregs->ds;
	M.x86.R_ES = sregs->es;
	M.x86.R_FS = sregs->fs;
	M.x86.R_GS = sregs->gs;
	((u8 *) M.mem_base)[0x4000] = 0xCD;
	((u8 *) M.mem_base)[0x4001] = (u8) intno;
	((u8 *) M.mem_base)[0x4002] = 0xF1;
	M.x86.R_CS = SEG(0x04000);
	M.x86.R_IP = OFF(0x04000);

	M.x86.R_SS = SEG(M.mem_size - 1);
	M.x86.R_SP = OFF(M.mem_size - 1) - 1;

	X86EMU_exec();
	out->e.cflag = M.x86.R_EFLG & F_CF;
	out->e.eax = M.x86.R_EAX;
	out->e.ebx = M.x86.R_EBX;
	out->e.ecx = M.x86.R_ECX;
	out->e.edx = M.x86.R_EDX;
	out->e.esi = M.x86.R_ESI;
	out->e.edi = M.x86.R_EDI;
	sregs->ds = M.x86.R_DS;
	sregs->es = M.x86.R_ES;
	sregs->fs = M.x86.R_FS;
	sregs->gs = M.x86.R_GS;
	return out->x.ax;
}
Commit	Line	Data
ece92f85 JJ	1	/****************************************************************************
ece92f85 JJ	2	*
9c7e4b06 WD	3	* BIOS emulator and interface
9c7e4b06 WD	4	* to Realmode X86 Emulator Library
ece92f85	5	*
4c2e3da8	6	* Copyright (C) 2007 Freescale Semiconductor, Inc.
ece92f85 JJ	7	* Jason Jin <Jason.jin@freescale.com>
ece92f85 JJ	8	*
9c7e4b06	9	* Copyright (C) 1996-1999 SciTech Software, Inc.
ece92f85 JJ	10	*
	11	* ========================================================================
	12	*
	13	* Permission to use, copy, modify, distribute, and sell this software and
	14	* its documentation for any purpose is hereby granted without fee,
	15	* provided that the above copyright notice appear in all copies and that
	16	* both that copyright notice and this permission notice appear in
	17	* supporting documentation, and that the name of the authors not be used
	18	* in advertising or publicity pertaining to distribution of the software
9c7e4b06	19	* without specific, written prior permission. The authors makes no
ece92f85 JJ	20	* representations about the suitability of this software for any purpose.
	21	* It is provided "as is" without express or implied warranty.
	22	*
	23	* THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
	24	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
	25	* EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
	26	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
	27	* USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
	28	* OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
	29	* PERFORMANCE OF THIS SOFTWARE.
	30	*
	31	* ========================================================================
	32	*
9c7e4b06 WD	33	* Language: ANSI C
	34	* Environment: Any
	35	* Developer: Kendall Bennett
ece92f85	36	*
9c7e4b06 WD	37	* Description: Module implementing the system specific functions. This
	38	* module is always compiled and linked in the OS depedent
	39	* libraries, and never in a binary portable driver.
ece92f85	40	*
9c7e4b06 WD	41	* Jason ported this file to u-boot to run the ATI video card BIOS
	42	* in u-boot. Made all the video memory be emulated during the
	43	* BIOS runing process which may affect the VGA function but the
	44	* frambuffer function can work after run the BIOS.
ece92f85 JJ	45	*
	46	****************************************************************************/
	47
ece92f85	48	#include <malloc.h>
78cff50e	49	#include <common.h>
5b4de930 MS	50	#include "biosemui.h"
5b4de930 MS	51
ece92f85	52	BE_sysEnv _BE_env = {{0}};
30c6a241	53	static X86EMU_memFuncs _BE_mem __attribute__((section(GOT2_TYPE))) = {
ece92f85 JJ	54	BE_rdb,
	55	BE_rdw,
	56	BE_rdl,
	57	BE_wrb,
	58	BE_wrw,
	59	BE_wrl,
	60	};
	61
30c6a241	62	static X86EMU_pioFuncs _BE_pio __attribute__((section(GOT2_TYPE))) = {
ece92f85 JJ	63	BE_inb,
	64	BE_inw,
	65	BE_inl,
	66	BE_outb,
	67	BE_outw,
	68	BE_outl,
	69	};
	70
9c7e4b06 WD	71	#define OFF(addr) (u16)(((addr) >> 0) & 0xffff)
9c7e4b06 WD	72	#define SEG(addr) (u16)(((addr) >> 4) & 0xf000)
ece92f85 JJ	73
	74	/****************************************************************************
	75	PARAMETERS:
	76	debugFlags - Flags to enable debugging options (debug builds only)
9c7e4b06 WD	77	memSize - Amount of memory to allocate for real mode machine
9c7e4b06 WD	78	info - Pointer to default VGA device information
ece92f85 JJ	79
	80	REMARKS:
	81	This functions initialises the BElib, and uses the passed in
	82	BIOS image as the BIOS that is used and emulated at 0xC0000.
	83	****************************************************************************/
	84	int X86API BE_init(u32 debugFlags, int memSize, BE_VGAInfo * info, int shared)
	85	{
	86	#if !defined(__DRIVER__) && !defined(__KERNEL__)
	87
	88	PM_init();
	89	#endif
	90	memset(&M, 0, sizeof(M));
	91	if (memSize < 20480){
	92	printf("Emulator requires at least 20Kb of memory!\n");
	93	return 0;
	94	}
	95
409ecdc0	96	M.mem_base = malloc(memSize);
ece92f85 JJ	97
	98	if (M.mem_base == NULL){
	99	printf("Biosemu:Out of memory!");
	100	return 0;
	101	}
	102	M.mem_size = memSize;
	103
	104	_BE_env.emulateVGA = 0;
	105	_BE_env.busmem_base = (unsigned long)malloc(128 * 1024);
409ecdc0	106	if ((void *)_BE_env.busmem_base == NULL){
ece92f85 JJ	107	printf("Biosemu:Out of memory!");
	108	return 0;
	109	}
	110	M.x86.debug = debugFlags;
	111	_BE_bios_init((u32*)info->LowMem);
	112	X86EMU_setupMemFuncs(&_BE_mem);
	113	X86EMU_setupPioFuncs(&_BE_pio);
	114	BE_setVGA(info);
	115	return 1;
	116	}
	117
	118	/****************************************************************************
	119	PARAMETERS:
9c7e4b06	120	info - Pointer to VGA device information to make current
ece92f85 JJ	121
	122	REMARKS:
	123	This function sets the VGA BIOS functions in the emulator to point to the
	124	specific VGA BIOS in use. This includes swapping the BIOS interrupt
	125	vectors, BIOS image and BIOS data area to the new BIOS. This allows the
	126	real mode BIOS to be swapped without resetting the entire emulator.
	127	****************************************************************************/
	128	void X86API BE_setVGA(BE_VGAInfo * info)
	129	{
	130
	131	#ifdef __KERNEL__
	132	_BE_env.vgaInfo.function = info->function;
	133	_BE_env.vgaInfo.device = info->device;
	134	_BE_env.vgaInfo.bus = info->bus;
	135	_BE_env.vgaInfo.pcidev = info->pcidev;
	136	#else
	137	_BE_env.vgaInfo.pciInfo = info->pciInfo;
	138	#endif
	139	_BE_env.vgaInfo.BIOSImage = info->BIOSImage;
	140	if (info->BIOSImage) {
	141	_BE_env.biosmem_base = (ulong) info->BIOSImage;
	142	_BE_env.biosmem_limit = 0xC0000 + info->BIOSImageLen - 1;
	143	} else {
	144	_BE_env.biosmem_base = _BE_env.busmem_base + 0x20000;
	145	_BE_env.biosmem_limit = 0xC7FFF;
	146	}
51d91e1a KG	147	if ((info->LowMem[0] == 0) && (info->LowMem[1] == 0) &&
51d91e1a KG	148	(info->LowMem[2] == 0) && (info->LowMem[3] == 0))
ece92f85 JJ	149	_BE_bios_init((u32 *) info->LowMem);
	150	memcpy((u8 *) M.mem_base, info->LowMem, sizeof(info->LowMem));
	151	}
	152
	153	/****************************************************************************
	154	PARAMETERS:
9c7e4b06	155	info - Pointer to VGA device information to retrieve current
ece92f85 JJ	156
	157	REMARKS:
	158	This function returns the VGA BIOS functions currently active in the
	159	emulator, so they can be restored at a later date.
	160	****************************************************************************/
	161	void X86API BE_getVGA(BE_VGAInfo * info)
	162	{
	163	#ifdef __KERNEL__
	164	info->function = _BE_env.vgaInfo.function;
	165	info->device = _BE_env.vgaInfo.device;
	166	info->bus = _BE_env.vgaInfo.bus;
	167	info->pcidev = _BE_env.vgaInfo.pcidev;
	168	#else
	169	info->pciInfo = _BE_env.vgaInfo.pciInfo;
	170	#endif
	171	info->BIOSImage = _BE_env.vgaInfo.BIOSImage;
	172	memcpy(info->LowMem, (u8 *) M.mem_base, sizeof(info->LowMem));
	173	}
	174
	175	/****************************************************************************
	176	PARAMETERS:
9c7e4b06 WD	177	r_seg - Segment for pointer to convert
9c7e4b06 WD	178	r_off - Offset for pointer to convert
ece92f85 JJ	179
	180	REMARKS:
	181	This function maps a real mode pointer in the emulator memory to a protected
	182	mode pointer that can be used to directly access the memory.
	183
9c7e4b06 WD	184	NOTE: The memory is always in little endian format, son on non-x86
	185	systems you will need to do endian translations to access this
	186	memory.
ece92f85 JJ	187	****************************************************************************/
	188	void *X86API BE_mapRealPointer(uint r_seg, uint r_off)
	189	{
	190	u32 addr = ((u32) r_seg << 4) + r_off;
	191
	192	if (addr >= 0xC0000 && addr <= _BE_env.biosmem_limit) {
	193	return (void *)(_BE_env.biosmem_base + addr - 0xC0000);
	194	} else if (addr >= 0xA0000 && addr <= 0xFFFFF) {
	195	return (void *)(_BE_env.busmem_base + addr - 0xA0000);
	196	}
	197	return (void *)(M.mem_base + addr);
	198	}
	199
	200	/****************************************************************************
	201	PARAMETERS:
9c7e4b06 WD	202	len - Return the length of the VESA buffer
	203	rseg - Place to store VESA buffer segment
	204	roff - Place to store VESA buffer offset
ece92f85 JJ	205
	206	REMARKS:
	207	This function returns the address of the VESA transfer buffer in real
	208	_BE_piomode emulator memory. The VESA transfer buffer is always 1024 bytes long,
	209	and located at 15Kb into the start of the real mode memory (16Kb is where
	210	we put the real mode code we execute for issuing interrupts).
	211
9c7e4b06 WD	212	NOTE: The memory is always in little endian format, son on non-x86
	213	systems you will need to do endian translations to access this
	214	memory.
ece92f85 JJ	215	****************************************************************************/
	216	void X86API BE_getVESABuf(uint len, uint * rseg, uint * roff)
	217	{
	218	*len = 1024;
	219	*rseg = SEG(0x03C00);
	220	*roff = OFF(0x03C00);
	221	return (void )(M.mem_base + ((u32) rseg << 4) + *roff);
	222	}
	223
	224	/****************************************************************************
	225	REMARKS:
	226	Cleans up and exits the emulator.
	227	****************************************************************************/
	228	void X86API BE_exit(void)
	229	{
	230	free(M.mem_base);
409ecdc0	231	free((void *)_BE_env.busmem_base);
ece92f85 JJ	232	}
	233
	234	/****************************************************************************
	235	PARAMETERS:
9c7e4b06 WD	236	seg - Segment of code to call
	237	off - Offset of code to call
	238	regs - Real mode registers to load
	239	sregs - Real mode segment registers to load
ece92f85 JJ	240
	241	REMARKS:
	242	This functions calls a real mode far function at the specified address,
	243	and loads all the x86 registers from the passed in registers structure.
	244	On exit the registers returned from the call are returned in the same
	245	structures.
	246	****************************************************************************/
	247	void X86API BE_callRealMode(uint seg, uint off, RMREGS * regs, RMSREGS * sregs)
	248	{
	249	M.x86.R_EAX = regs->e.eax;
	250	M.x86.R_EBX = regs->e.ebx;
	251	M.x86.R_ECX = regs->e.ecx;
	252	M.x86.R_EDX = regs->e.edx;
	253	M.x86.R_ESI = regs->e.esi;
	254	M.x86.R_EDI = regs->e.edi;
	255	M.x86.R_DS = sregs->ds;
	256	M.x86.R_ES = sregs->es;
	257	M.x86.R_FS = sregs->fs;
	258	M.x86.R_GS = sregs->gs;
	259
	260	((u8 *) M.mem_base)[0x4000] = 0x9A;
	261	((u8 *) M.mem_base)[0x4001] = (u8) off;
	262	((u8 *) M.mem_base)[0x4002] = (u8) (off >> 8);
	263	((u8 *) M.mem_base)[0x4003] = (u8) seg;
	264	((u8 *) M.mem_base)[0x4004] = (u8) (seg >> 8);
	265	((u8 ) M.mem_base)[0x4005] = 0xF1; / Illegal op-code */
	266	M.x86.R_CS = SEG(0x04000);
	267	M.x86.R_IP = OFF(0x04000);
	268
	269	M.x86.R_SS = SEG(M.mem_size - 2);
	270	M.x86.R_SP = OFF(M.mem_size - 2) + 2;
	271
	272	X86EMU_exec();
	273
	274	regs->e.cflag = M.x86.R_EFLG & F_CF;
	275	regs->e.eax = M.x86.R_EAX;
	276	regs->e.ebx = M.x86.R_EBX;
	277	regs->e.ecx = M.x86.R_ECX;
	278	regs->e.edx = M.x86.R_EDX;
	279	regs->e.esi = M.x86.R_ESI;
	280	regs->e.edi = M.x86.R_EDI;
	281	sregs->ds = M.x86.R_DS;
	282	sregs->es = M.x86.R_ES;
	283	sregs->fs = M.x86.R_FS;
	284	sregs->gs = M.x86.R_GS;
	285	}
	286
	287	/****************************************************************************
	288	PARAMETERS:
9c7e4b06 WD	289	intno - Interrupt number to execute
	290	in - Real mode registers to load
	291	out - Place to store resulting real mode registers
ece92f85 JJ	292
	293	REMARKS:
	294	This functions calls a real mode interrupt function at the specified address,
	295	and loads all the x86 registers from the passed in registers structure.
	296	On exit the registers returned from the call are returned in out stucture.
	297	****************************************************************************/
	298	int X86API BE_int86(int intno, RMREGS * in, RMREGS * out)
	299	{
	300	M.x86.R_EAX = in->e.eax;
	301	M.x86.R_EBX = in->e.ebx;
	302	M.x86.R_ECX = in->e.ecx;
	303	M.x86.R_EDX = in->e.edx;
	304	M.x86.R_ESI = in->e.esi;
	305	M.x86.R_EDI = in->e.edi;
	306	((u8 *) M.mem_base)[0x4000] = 0xCD;
	307	((u8 *) M.mem_base)[0x4001] = (u8) intno;
	308	((u8 *) M.mem_base)[0x4002] = 0xF1;
	309	M.x86.R_CS = SEG(0x04000);
	310	M.x86.R_IP = OFF(0x04000);
	311
	312	M.x86.R_SS = SEG(M.mem_size - 1);
	313	M.x86.R_SP = OFF(M.mem_size - 1) - 1;
	314
	315	X86EMU_exec();
	316	out->e.cflag = M.x86.R_EFLG & F_CF;
	317	out->e.eax = M.x86.R_EAX;
	318	out->e.ebx = M.x86.R_EBX;
	319	out->e.ecx = M.x86.R_ECX;
	320	out->e.edx = M.x86.R_EDX;
	321	out->e.esi = M.x86.R_ESI;
	322	out->e.edi = M.x86.R_EDI;
	323	return out->x.ax;
	324	}
	325
	326	/****************************************************************************
	327	PARAMETERS:
9c7e4b06 WD	328	intno - Interrupt number to execute
	329	in - Real mode registers to load
	330	out - Place to store resulting real mode registers
	331	sregs - Real mode segment registers to load
ece92f85 JJ	332
	333	REMARKS:
	334	This functions calls a real mode interrupt function at the specified address,
	335	and loads all the x86 registers from the passed in registers structure.
	336	On exit the registers returned from the call are returned in out stucture.
	337	****************************************************************************/
	338	int X86API BE_int86x(int intno, RMREGS * in, RMREGS * out, RMSREGS * sregs)
	339	{
	340	M.x86.R_EAX = in->e.eax;
	341	M.x86.R_EBX = in->e.ebx;
	342	M.x86.R_ECX = in->e.ecx;
	343	M.x86.R_EDX = in->e.edx;
	344	M.x86.R_ESI = in->e.esi;
	345	M.x86.R_EDI = in->e.edi;
	346	M.x86.R_DS = sregs->ds;
	347	M.x86.R_ES = sregs->es;
	348	M.x86.R_FS = sregs->fs;
	349	M.x86.R_GS = sregs->gs;
	350	((u8 *) M.mem_base)[0x4000] = 0xCD;
	351	((u8 *) M.mem_base)[0x4001] = (u8) intno;
	352	((u8 *) M.mem_base)[0x4002] = 0xF1;
	353	M.x86.R_CS = SEG(0x04000);
	354	M.x86.R_IP = OFF(0x04000);
	355
	356	M.x86.R_SS = SEG(M.mem_size - 1);
	357	M.x86.R_SP = OFF(M.mem_size - 1) - 1;
	358
	359	X86EMU_exec();
	360	out->e.cflag = M.x86.R_EFLG & F_CF;
	361	out->e.eax = M.x86.R_EAX;
	362	out->e.ebx = M.x86.R_EBX;
	363	out->e.ecx = M.x86.R_ECX;
	364	out->e.edx = M.x86.R_EDX;
	365	out->e.esi = M.x86.R_ESI;
	366	out->e.edi = M.x86.R_EDI;
	367	sregs->ds = M.x86.R_DS;
	368	sregs->es = M.x86.R_ES;
	369	sregs->fs = M.x86.R_FS;
	370	sregs->gs = M.x86.R_GS;
	371	return out->x.ax;
	372	}