[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. All rights reserved.
*  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>

#if defined(CONFIG_BIOSEMU)

#include "biosemui.h"

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

static X86EMU_pioFuncs _BE_pio __attribute__((section(".got2"))) = {
	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 (*((u32 *) info->LowMem) == 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;
}
#endif
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 JJ	5	*
	6	* Copyright (C) 2007 Freescale Semiconductor, Inc. All rights reserved.
	7	* Jason Jin <Jason.jin@freescale.com>
	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>
ece92f85	50
ce981dc8 JJ	51	#if defined(CONFIG_BIOSEMU)
ce981dc8 JJ	52
5b4de930 MS	53	#include "biosemui.h"
5b4de930 MS	54
ece92f85 JJ	55	BE_sysEnv _BE_env = {{0}};
	56	static X86EMU_memFuncs _BE_mem __attribute__((section(".got2"))) = {
	57	BE_rdb,
	58	BE_rdw,
	59	BE_rdl,
	60	BE_wrb,
	61	BE_wrw,
	62	BE_wrl,
	63	};
	64
	65	static X86EMU_pioFuncs _BE_pio __attribute__((section(".got2"))) = {
	66	BE_inb,
	67	BE_inw,
	68	BE_inl,
	69	BE_outb,
	70	BE_outw,
	71	BE_outl,
	72	};
	73
9c7e4b06 WD	74	#define OFF(addr) (u16)(((addr) >> 0) & 0xffff)
9c7e4b06 WD	75	#define SEG(addr) (u16)(((addr) >> 4) & 0xf000)
ece92f85 JJ	76
	77	/****************************************************************************
	78	PARAMETERS:
	79	debugFlags - Flags to enable debugging options (debug builds only)
9c7e4b06 WD	80	memSize - Amount of memory to allocate for real mode machine
9c7e4b06 WD	81	info - Pointer to default VGA device information
ece92f85 JJ	82
	83	REMARKS:
	84	This functions initialises the BElib, and uses the passed in
	85	BIOS image as the BIOS that is used and emulated at 0xC0000.
	86	****************************************************************************/
	87	int X86API BE_init(u32 debugFlags, int memSize, BE_VGAInfo * info, int shared)
	88	{
	89	#if !defined(__DRIVER__) && !defined(__KERNEL__)
	90
	91	PM_init();
	92	#endif
	93	memset(&M, 0, sizeof(M));
	94	if (memSize < 20480){
	95	printf("Emulator requires at least 20Kb of memory!\n");
	96	return 0;
	97	}
	98
409ecdc0	99	M.mem_base = malloc(memSize);
ece92f85 JJ	100
	101	if (M.mem_base == NULL){
	102	printf("Biosemu:Out of memory!");
	103	return 0;
	104	}
	105	M.mem_size = memSize;
	106
	107	_BE_env.emulateVGA = 0;
	108	_BE_env.busmem_base = (unsigned long)malloc(128 * 1024);
409ecdc0	109	if ((void *)_BE_env.busmem_base == NULL){
ece92f85 JJ	110	printf("Biosemu:Out of memory!");
	111	return 0;
	112	}
	113	M.x86.debug = debugFlags;
	114	_BE_bios_init((u32*)info->LowMem);
	115	X86EMU_setupMemFuncs(&_BE_mem);
	116	X86EMU_setupPioFuncs(&_BE_pio);
	117	BE_setVGA(info);
	118	return 1;
	119	}
	120
	121	/****************************************************************************
	122	PARAMETERS:
9c7e4b06	123	info - Pointer to VGA device information to make current
ece92f85 JJ	124
	125	REMARKS:
	126	This function sets the VGA BIOS functions in the emulator to point to the
	127	specific VGA BIOS in use. This includes swapping the BIOS interrupt
	128	vectors, BIOS image and BIOS data area to the new BIOS. This allows the
	129	real mode BIOS to be swapped without resetting the entire emulator.
	130	****************************************************************************/
	131	void X86API BE_setVGA(BE_VGAInfo * info)
	132	{
	133
	134	#ifdef __KERNEL__
	135	_BE_env.vgaInfo.function = info->function;
	136	_BE_env.vgaInfo.device = info->device;
	137	_BE_env.vgaInfo.bus = info->bus;
	138	_BE_env.vgaInfo.pcidev = info->pcidev;
	139	#else
	140	_BE_env.vgaInfo.pciInfo = info->pciInfo;
	141	#endif
	142	_BE_env.vgaInfo.BIOSImage = info->BIOSImage;
	143	if (info->BIOSImage) {
	144	_BE_env.biosmem_base = (ulong) info->BIOSImage;
	145	_BE_env.biosmem_limit = 0xC0000 + info->BIOSImageLen - 1;
	146	} else {
	147	_BE_env.biosmem_base = _BE_env.busmem_base + 0x20000;
	148	_BE_env.biosmem_limit = 0xC7FFF;
	149	}
	150	if (((u32 ) info->LowMem) == 0)
	151	_BE_bios_init((u32 *) info->LowMem);
	152	memcpy((u8 *) M.mem_base, info->LowMem, sizeof(info->LowMem));
	153	}
	154
	155	/****************************************************************************
	156	PARAMETERS:
9c7e4b06	157	info - Pointer to VGA device information to retrieve current
ece92f85 JJ	158
	159	REMARKS:
	160	This function returns the VGA BIOS functions currently active in the
	161	emulator, so they can be restored at a later date.
	162	****************************************************************************/
	163	void X86API BE_getVGA(BE_VGAInfo * info)
	164	{
	165	#ifdef __KERNEL__
	166	info->function = _BE_env.vgaInfo.function;
	167	info->device = _BE_env.vgaInfo.device;
	168	info->bus = _BE_env.vgaInfo.bus;
	169	info->pcidev = _BE_env.vgaInfo.pcidev;
	170	#else
	171	info->pciInfo = _BE_env.vgaInfo.pciInfo;
	172	#endif
	173	info->BIOSImage = _BE_env.vgaInfo.BIOSImage;
	174	memcpy(info->LowMem, (u8 *) M.mem_base, sizeof(info->LowMem));
	175	}
	176
	177	/****************************************************************************
	178	PARAMETERS:
9c7e4b06 WD	179	r_seg - Segment for pointer to convert
9c7e4b06 WD	180	r_off - Offset for pointer to convert
ece92f85 JJ	181
	182	REMARKS:
	183	This function maps a real mode pointer in the emulator memory to a protected
	184	mode pointer that can be used to directly access the memory.
	185
9c7e4b06 WD	186	NOTE: The memory is always in little endian format, son on non-x86
	187	systems you will need to do endian translations to access this
	188	memory.
ece92f85 JJ	189	****************************************************************************/
	190	void *X86API BE_mapRealPointer(uint r_seg, uint r_off)
	191	{
	192	u32 addr = ((u32) r_seg << 4) + r_off;
	193
	194	if (addr >= 0xC0000 && addr <= _BE_env.biosmem_limit) {
	195	return (void *)(_BE_env.biosmem_base + addr - 0xC0000);
	196	} else if (addr >= 0xA0000 && addr <= 0xFFFFF) {
	197	return (void *)(_BE_env.busmem_base + addr - 0xA0000);
	198	}
	199	return (void *)(M.mem_base + addr);
	200	}
	201
	202	/****************************************************************************
	203	PARAMETERS:
9c7e4b06 WD	204	len - Return the length of the VESA buffer
	205	rseg - Place to store VESA buffer segment
	206	roff - Place to store VESA buffer offset
ece92f85 JJ	207
	208	REMARKS:
	209	This function returns the address of the VESA transfer buffer in real
	210	_BE_piomode emulator memory. The VESA transfer buffer is always 1024 bytes long,
	211	and located at 15Kb into the start of the real mode memory (16Kb is where
	212	we put the real mode code we execute for issuing interrupts).
	213
9c7e4b06 WD	214	NOTE: The memory is always in little endian format, son on non-x86
	215	systems you will need to do endian translations to access this
	216	memory.
ece92f85 JJ	217	****************************************************************************/
	218	void X86API BE_getVESABuf(uint len, uint * rseg, uint * roff)
	219	{
	220	*len = 1024;
	221	*rseg = SEG(0x03C00);
	222	*roff = OFF(0x03C00);
	223	return (void )(M.mem_base + ((u32) rseg << 4) + *roff);
	224	}
	225
	226	/****************************************************************************
	227	REMARKS:
	228	Cleans up and exits the emulator.
	229	****************************************************************************/
	230	void X86API BE_exit(void)
	231	{
	232	free(M.mem_base);
409ecdc0	233	free((void *)_BE_env.busmem_base);
ece92f85 JJ	234	}
	235
	236	/****************************************************************************
	237	PARAMETERS:
9c7e4b06 WD	238	seg - Segment of code to call
	239	off - Offset of code to call
	240	regs - Real mode registers to load
	241	sregs - Real mode segment registers to load
ece92f85 JJ	242
	243	REMARKS:
	244	This functions calls a real mode far function at the specified address,
	245	and loads all the x86 registers from the passed in registers structure.
	246	On exit the registers returned from the call are returned in the same
	247	structures.
	248	****************************************************************************/
	249	void X86API BE_callRealMode(uint seg, uint off, RMREGS * regs, RMSREGS * sregs)
	250	{
	251	M.x86.R_EAX = regs->e.eax;
	252	M.x86.R_EBX = regs->e.ebx;
	253	M.x86.R_ECX = regs->e.ecx;
	254	M.x86.R_EDX = regs->e.edx;
	255	M.x86.R_ESI = regs->e.esi;
	256	M.x86.R_EDI = regs->e.edi;
	257	M.x86.R_DS = sregs->ds;
	258	M.x86.R_ES = sregs->es;
	259	M.x86.R_FS = sregs->fs;
	260	M.x86.R_GS = sregs->gs;
	261
	262	((u8 *) M.mem_base)[0x4000] = 0x9A;
	263	((u8 *) M.mem_base)[0x4001] = (u8) off;
	264	((u8 *) M.mem_base)[0x4002] = (u8) (off >> 8);
	265	((u8 *) M.mem_base)[0x4003] = (u8) seg;
	266	((u8 *) M.mem_base)[0x4004] = (u8) (seg >> 8);
	267	((u8 ) M.mem_base)[0x4005] = 0xF1; / Illegal op-code */
	268	M.x86.R_CS = SEG(0x04000);
	269	M.x86.R_IP = OFF(0x04000);
	270
	271	M.x86.R_SS = SEG(M.mem_size - 2);
	272	M.x86.R_SP = OFF(M.mem_size - 2) + 2;
	273
	274	X86EMU_exec();
	275
	276	regs->e.cflag = M.x86.R_EFLG & F_CF;
	277	regs->e.eax = M.x86.R_EAX;
	278	regs->e.ebx = M.x86.R_EBX;
	279	regs->e.ecx = M.x86.R_ECX;
	280	regs->e.edx = M.x86.R_EDX;
	281	regs->e.esi = M.x86.R_ESI;
	282	regs->e.edi = M.x86.R_EDI;
	283	sregs->ds = M.x86.R_DS;
	284	sregs->es = M.x86.R_ES;
	285	sregs->fs = M.x86.R_FS;
	286	sregs->gs = M.x86.R_GS;
	287	}
	288
	289	/****************************************************************************
	290	PARAMETERS:
9c7e4b06 WD	291	intno - Interrupt number to execute
	292	in - Real mode registers to load
	293	out - Place to store resulting real mode registers
ece92f85 JJ	294
	295	REMARKS:
	296	This functions calls a real mode interrupt function at the specified address,
	297	and loads all the x86 registers from the passed in registers structure.
	298	On exit the registers returned from the call are returned in out stucture.
	299	****************************************************************************/
	300	int X86API BE_int86(int intno, RMREGS * in, RMREGS * out)
	301	{
	302	M.x86.R_EAX = in->e.eax;
	303	M.x86.R_EBX = in->e.ebx;
	304	M.x86.R_ECX = in->e.ecx;
	305	M.x86.R_EDX = in->e.edx;
	306	M.x86.R_ESI = in->e.esi;
	307	M.x86.R_EDI = in->e.edi;
	308	((u8 *) M.mem_base)[0x4000] = 0xCD;
	309	((u8 *) M.mem_base)[0x4001] = (u8) intno;
	310	((u8 *) M.mem_base)[0x4002] = 0xF1;
	311	M.x86.R_CS = SEG(0x04000);
	312	M.x86.R_IP = OFF(0x04000);
	313
	314	M.x86.R_SS = SEG(M.mem_size - 1);
	315	M.x86.R_SP = OFF(M.mem_size - 1) - 1;
	316
	317	X86EMU_exec();
	318	out->e.cflag = M.x86.R_EFLG & F_CF;
	319	out->e.eax = M.x86.R_EAX;
	320	out->e.ebx = M.x86.R_EBX;
	321	out->e.ecx = M.x86.R_ECX;
	322	out->e.edx = M.x86.R_EDX;
	323	out->e.esi = M.x86.R_ESI;
	324	out->e.edi = M.x86.R_EDI;
	325	return out->x.ax;
	326	}
	327
	328	/****************************************************************************
	329	PARAMETERS:
9c7e4b06 WD	330	intno - Interrupt number to execute
	331	in - Real mode registers to load
	332	out - Place to store resulting real mode registers
	333	sregs - Real mode segment registers to load
ece92f85 JJ	334
	335	REMARKS:
	336	This functions calls a real mode interrupt function at the specified address,
	337	and loads all the x86 registers from the passed in registers structure.
	338	On exit the registers returned from the call are returned in out stucture.
	339	****************************************************************************/
	340	int X86API BE_int86x(int intno, RMREGS * in, RMREGS * out, RMSREGS * sregs)
	341	{
	342	M.x86.R_EAX = in->e.eax;
	343	M.x86.R_EBX = in->e.ebx;
	344	M.x86.R_ECX = in->e.ecx;
	345	M.x86.R_EDX = in->e.edx;
	346	M.x86.R_ESI = in->e.esi;
	347	M.x86.R_EDI = in->e.edi;
	348	M.x86.R_DS = sregs->ds;
	349	M.x86.R_ES = sregs->es;
	350	M.x86.R_FS = sregs->fs;
	351	M.x86.R_GS = sregs->gs;
	352	((u8 *) M.mem_base)[0x4000] = 0xCD;
	353	((u8 *) M.mem_base)[0x4001] = (u8) intno;
	354	((u8 *) M.mem_base)[0x4002] = 0xF1;
	355	M.x86.R_CS = SEG(0x04000);
	356	M.x86.R_IP = OFF(0x04000);
	357
	358	M.x86.R_SS = SEG(M.mem_size - 1);
	359	M.x86.R_SP = OFF(M.mem_size - 1) - 1;
	360
	361	X86EMU_exec();
	362	out->e.cflag = M.x86.R_EFLG & F_CF;
	363	out->e.eax = M.x86.R_EAX;
	364	out->e.ebx = M.x86.R_EBX;
	365	out->e.ecx = M.x86.R_ECX;
	366	out->e.edx = M.x86.R_EDX;
	367	out->e.esi = M.x86.R_ESI;
	368	out->e.edi = M.x86.R_EDI;
	369	sregs->ds = M.x86.R_DS;
	370	sregs->es = M.x86.R_ES;
	371	sregs->fs = M.x86.R_FS;
	372	sregs->gs = M.x86.R_GS;
	373	return out->x.ax;
	374	}
ce981dc8	375	#endif