[ipfire-2.x.git] / src / hwinfo / src / x86emu / sys.c

/****************************************************************************
*
*						Realmode X86 Emulator Library
*
*            	Copyright (C) 1996-1999 SciTech Software, Inc.
* 				     Copyright (C) David Mosberger-Tang
* 					   Copyright (C) 1999 Egbert Eich
*
*  ========================================================================
*
*  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:  This file includes subroutines which are related to
*				programmed I/O and memory access. Included in this module
*				are default functions with limited usefulness. For real
*				uses these functions will most likely be overriden by the
*				user library.
*
****************************************************************************/
/* $XFree86: xc/extras/x86emu/src/x86emu/sys.c,v 1.6 2002/09/16 18:05:18 eich Exp $ */

#include "x86emu.h"
#include "x86emu/x86emui.h"
#include "x86emu/regs.h"
#include "x86emu/debug.h"
#include "x86emu/prim_ops.h"
#ifdef IN_MODULE
#include "xf86_ansic.h"
#else
#include <string.h>
#endif                                                                                           
/*------------------------- Global Variables ------------------------------*/

X86EMU_sysEnv		_X86EMU_env;		/* Global emulator machine state */
X86EMU_intrFuncs	_X86EMU_intrTab[256];

/*----------------------------- Implementation ----------------------------*/
#if defined(__alpha__) || defined(__alpha)
/* to cope with broken egcs-1.1.2 :-(((( */

#define ALPHA_UALOADS
/*
 * inline functions to do unaligned accesses
 * from linux/include/asm-alpha/unaligned.h
 */

/*
 * EGCS 1.1 knows about arbitrary unaligned loads.  Define some
 * packed structures to talk about such things with.
 */

#if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
struct __una_u64 { unsigned long  x __attribute__((packed)); };
struct __una_u32 { unsigned int   x __attribute__((packed)); };
struct __una_u16 { unsigned short x __attribute__((packed)); };
#endif

static __inline__ unsigned long ldq_u(unsigned long * r11)
{
#if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
	const struct __una_u64 *ptr = (const struct __una_u64 *) r11;
	return ptr->x;
#else
	unsigned long r1,r2;
	__asm__("ldq_u %0,%3\n\t"
		"ldq_u %1,%4\n\t"
		"extql %0,%2,%0\n\t"
		"extqh %1,%2,%1"
		:"=&r" (r1), "=&r" (r2)
		:"r" (r11),
		 "m" (*r11),
		 "m" (*(const unsigned long *)(7+(char *) r11)));
	return r1 | r2;
#endif
}

static __inline__ unsigned long ldl_u(unsigned int * r11)
{
#if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
	const struct __una_u32 *ptr = (const struct __una_u32 *) r11;
	return ptr->x;
#else
	unsigned long r1,r2;
	__asm__("ldq_u %0,%3\n\t"
		"ldq_u %1,%4\n\t"
		"extll %0,%2,%0\n\t"
		"extlh %1,%2,%1"
		:"=&r" (r1), "=&r" (r2)
		:"r" (r11),
		 "m" (*r11),
		 "m" (*(const unsigned long *)(3+(char *) r11)));
	return r1 | r2;
#endif
}

static __inline__ unsigned long ldw_u(unsigned short * r11)
{
#if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
	const struct __una_u16 *ptr = (const struct __una_u16 *) r11;
	return ptr->x;
#else
	unsigned long r1,r2;
	__asm__("ldq_u %0,%3\n\t"
		"ldq_u %1,%4\n\t"
		"extwl %0,%2,%0\n\t"
		"extwh %1,%2,%1"
		:"=&r" (r1), "=&r" (r2)
		:"r" (r11),
		 "m" (*r11),
		 "m" (*(const unsigned long *)(1+(char *) r11)));
	return r1 | r2;
#endif
}

/*
 * Elemental unaligned stores 
 */

static __inline__ void stq_u(unsigned long r5, unsigned long * r11)
{
#if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
	struct __una_u64 *ptr = (struct __una_u64 *) r11;
	ptr->x = r5;
#else
	unsigned long r1,r2,r3,r4;

	__asm__("ldq_u %3,%1\n\t"
		"ldq_u %2,%0\n\t"
		"insqh %6,%7,%5\n\t"
		"insql %6,%7,%4\n\t"
		"mskqh %3,%7,%3\n\t"
		"mskql %2,%7,%2\n\t"
		"bis %3,%5,%3\n\t"
		"bis %2,%4,%2\n\t"
		"stq_u %3,%1\n\t"
		"stq_u %2,%0"
		:"=m" (*r11),
		 "=m" (*(unsigned long *)(7+(char *) r11)),
		 "=&r" (r1), "=&r" (r2), "=&r" (r3), "=&r" (r4)
		:"r" (r5), "r" (r11));
#endif
}

static __inline__ void stl_u(unsigned long r5, unsigned int * r11)
{
#if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
	struct __una_u32 *ptr = (struct __una_u32 *) r11;
	ptr->x = r5;
#else
	unsigned long r1,r2,r3,r4;

	__asm__("ldq_u %3,%1\n\t"
		"ldq_u %2,%0\n\t"
		"inslh %6,%7,%5\n\t"
		"insll %6,%7,%4\n\t"
		"msklh %3,%7,%3\n\t"
		"mskll %2,%7,%2\n\t"
		"bis %3,%5,%3\n\t"
		"bis %2,%4,%2\n\t"
		"stq_u %3,%1\n\t"
		"stq_u %2,%0"
		:"=m" (*r11),
		 "=m" (*(unsigned long *)(3+(char *) r11)),
		 "=&r" (r1), "=&r" (r2), "=&r" (r3), "=&r" (r4)
		:"r" (r5), "r" (r11));
#endif
}

static __inline__ void stw_u(unsigned long r5, unsigned short * r11)
{
#if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
	struct __una_u16 *ptr = (struct __una_u16 *) r11;
	ptr->x = r5;
#else
	unsigned long r1,r2,r3,r4;

	__asm__("ldq_u %3,%1\n\t"
		"ldq_u %2,%0\n\t"
		"inswh %6,%7,%5\n\t"
		"inswl %6,%7,%4\n\t"
		"mskwh %3,%7,%3\n\t"
		"mskwl %2,%7,%2\n\t"
		"bis %3,%5,%3\n\t"
		"bis %2,%4,%2\n\t"
		"stq_u %3,%1\n\t"
		"stq_u %2,%0"
		:"=m" (*r11),
		 "=m" (*(unsigned long *)(1+(char *) r11)),
		 "=&r" (r1), "=&r" (r2), "=&r" (r3), "=&r" (r4)
		:"r" (r5), "r" (r11));
#endif
}

#elif defined(__GNUC__) && ((__GNUC__ < 3)) && \
             (defined (__ia64__) || defined (ia64__))
#define IA64_UALOADS
/*
 * EGCS 1.1 knows about arbitrary unaligned loads.  Define some
 * packed structures to talk about such things with.
 */
struct __una_u64 { unsigned long  x __attribute__((packed)); };
struct __una_u32 { unsigned int   x __attribute__((packed)); };
struct __una_u16 { unsigned short x __attribute__((packed)); };

static __inline__ unsigned long
__uldq (const unsigned long * r11)
{
    const struct __una_u64 *ptr = (const struct __una_u64 *) r11;
    return ptr->x;
}

static __inline__ unsigned long
uldl (const unsigned int * r11)
{
    const struct __una_u32 *ptr = (const struct __una_u32 *) r11;
    return ptr->x;
}

static __inline__ unsigned long
uldw (const unsigned short * r11)
{
    const struct __una_u16 *ptr = (const struct __una_u16 *) r11;
    return ptr->x;
}

static __inline__ void
ustq (unsigned long r5, unsigned long * r11)
{
    struct __una_u64 *ptr = (struct __una_u64 *) r11;
    ptr->x = r5;
}

static __inline__ void
ustl (unsigned long r5, unsigned int * r11)
{
    struct __una_u32 *ptr = (struct __una_u32 *) r11;
    ptr->x = r5;
}

static __inline__ void
ustw (unsigned long r5, unsigned short * r11)
{
    struct __una_u16 *ptr = (struct __una_u16 *) r11;
    ptr->x = r5;
}

#endif

/****************************************************************************
PARAMETERS:
addr	- Emulator memory address to read

RETURNS:
Byte value read from emulator memory.

REMARKS:
Reads a byte value from the emulator memory. 
****************************************************************************/
u8 X86API rdb(
    u32 addr)
{
	u8 val;

	if (addr > M.mem_size - 1) {
		DB(printk("mem_read: address %#lx out of range!\n", addr);)
		HALT_SYS();
		}
	val = *(u8*)(M.mem_base + addr);
DB(	if (DEBUG_MEM_TRACE())
		printk("%#08x 1 -> %#x\n", addr, val);)
	return val;
}

/****************************************************************************
PARAMETERS:
addr	- Emulator memory address to read

RETURNS:
Word value read from emulator memory.

REMARKS:
Reads a word value from the emulator memory.
****************************************************************************/
u16 X86API rdw(
	u32 addr)
{
	u16 val = 0;

	if (addr > M.mem_size - 2) {
		DB(printk("mem_read: address %#lx out of range!\n", addr);)
		HALT_SYS();
		}
#ifdef __BIG_ENDIAN__
	if (addr & 0x1) {
		val = (*(u8*)(M.mem_base + addr) |
			  (*(u8*)(M.mem_base + addr + 1) << 8));
		}
	else
#endif
#if defined(ALPHA_UALOADS)
		val = ldw_u((u16*)(M.mem_base + addr));
#elif  defined(IA64_UALOADS)
      val = uldw((u16*)(M.mem_base + addr));
#else
		val = *(u16*)(M.mem_base + addr);
#endif
		DB(	if (DEBUG_MEM_TRACE())
		printk("%#08x 2 -> %#x\n", addr, val);)
    return val;
}

/****************************************************************************
PARAMETERS:
addr	- Emulator memory address to read

RETURNS:
Long value read from emulator memory.
REMARKS:
Reads a long value from the emulator memory. 
****************************************************************************/
u32 X86API rdl(
	u32 addr)
{
	u32 val = 0;

	if (addr > M.mem_size - 4) {
		DB(printk("mem_read: address %#lx out of range!\n", addr);)
		HALT_SYS();
		}
#ifdef __BIG_ENDIAN__
	if (addr & 0x3) {
		val = (*(u8*)(M.mem_base + addr + 0) |
			  (*(u8*)(M.mem_base + addr + 1) << 8) |
			  (*(u8*)(M.mem_base + addr + 2) << 16) |
			  (*(u8*)(M.mem_base + addr + 3) << 24));
		}
	else
#endif
#if defined(ALPHA_UALOADS)
		val = ldl_u((u32*)(M.mem_base + addr));
#elif  defined(IA64_UALOADS)
        val = uldl((u32*)(M.mem_base + addr));
#else
		val = *(u32*)(M.mem_base + addr);
#endif
DB(	if (DEBUG_MEM_TRACE())
		printk("%#08x 4 -> %#x\n", addr, val);)
	return val;
}

/****************************************************************************
PARAMETERS:
addr	- Emulator memory address to read
val		- Value to store

REMARKS:
Writes a byte value to emulator memory.
****************************************************************************/
void X86API wrb(
	u32 addr,
	u8 val)
{
DB(	if (DEBUG_MEM_TRACE())
		printk("%#08x 1 <- %#x\n", addr, val);)
    if (addr > M.mem_size - 1) {
		DB(printk("mem_write: address %#lx out of range!\n", addr);)
		HALT_SYS();
		}
	*(u8*)(M.mem_base + addr) = val;
}

/****************************************************************************
PARAMETERS:
addr	- Emulator memory address to read
val		- Value to store

REMARKS:
Writes a word value to emulator memory.
****************************************************************************/
void X86API wrw(
	u32 addr,
	u16 val)
{
DB(	if (DEBUG_MEM_TRACE())
		printk("%#08x 2 <- %#x\n", addr, val);)
	if (addr > M.mem_size - 2) {
		DB(printk("mem_write: address %#lx out of range!\n", addr);)
		HALT_SYS();
		}
#ifdef __BIG_ENDIAN__
	if (addr & 0x1) {
		*(u8*)(M.mem_base + addr + 0) = (val >> 0) & 0xff;
		*(u8*)(M.mem_base + addr + 1) = (val >> 8) & 0xff;
		}
	else
#endif
#if defined(ALPHA_UALOADS)
	 stw_u(val,(u16*)(M.mem_base + addr));
#elif defined(IA64_UALOADS)
     ustw(val,(u16*)(M.mem_base + addr));
#else
	 *(u16*)(M.mem_base + addr) = val;
#endif
}

/****************************************************************************
PARAMETERS:
addr	- Emulator memory address to read
val		- Value to store

REMARKS:
Writes a long value to emulator memory. 
****************************************************************************/
void X86API wrl(
	u32 addr,
	u32 val)
{
DB(	if (DEBUG_MEM_TRACE())
		printk("%#08x 4 <- %#x\n", addr, val);)
	if (addr > M.mem_size - 4) {
		DB(printk("mem_write: address %#lx out of range!\n", addr);)
		HALT_SYS();
		}
#ifdef __BIG_ENDIAN__
	if (addr & 0x1) {
		*(u8*)(M.mem_base + addr + 0) = (val >>  0) & 0xff;
		*(u8*)(M.mem_base + addr + 1) = (val >>  8) & 0xff;
		*(u8*)(M.mem_base + addr + 2) = (val >> 16) & 0xff;
		*(u8*)(M.mem_base + addr + 3) = (val >> 24) & 0xff;
		}
	else
#endif
#if defined(ALPHA_UALOADS)
	 stl_u(val,(u32*)(M.mem_base + addr));
#elif defined(IA64_UALOADS)
     ustl(val,(u32*)(M.mem_base + addr));
#else
	 *(u32*)(M.mem_base + addr) = val;
#endif
}

/****************************************************************************
PARAMETERS:
addr	- PIO address to read
RETURN:
0
REMARKS:
Default PIO byte read function. Doesn't perform real inb.
****************************************************************************/
static u8 X86API p_inb(
	X86EMU_pioAddr addr)
{
DB(	if (DEBUG_IO_TRACE())
		printk("inb %#04x \n", addr);)
	return 0;
}

/****************************************************************************
PARAMETERS:
addr	- PIO address to read
RETURN:
0
REMARKS:
Default PIO word read function. Doesn't perform real inw.
****************************************************************************/
static u16 X86API p_inw(
	X86EMU_pioAddr addr)
{
DB(	if (DEBUG_IO_TRACE())
		printk("inw %#04x \n", addr);)
	return 0;
}

/****************************************************************************
PARAMETERS:
addr	- PIO address to read
RETURN:
0
REMARKS:
Default PIO long read function. Doesn't perform real inl.
****************************************************************************/
static u32 X86API p_inl(
	X86EMU_pioAddr addr)
{
DB(	if (DEBUG_IO_TRACE())
		printk("inl %#04x \n", addr);)
	return 0;
}

/****************************************************************************
PARAMETERS:
addr	- PIO address to write
val     - Value to store
REMARKS:
Default PIO byte write function. Doesn't perform real outb.
****************************************************************************/
static void X86API p_outb(
	X86EMU_pioAddr addr,
	u8 val)
{
DB(	if (DEBUG_IO_TRACE())
		printk("outb %#02x -> %#04x \n", val, addr);)
    return;
}

/****************************************************************************
PARAMETERS:
addr	- PIO address to write
val     - Value to store
REMARKS:
Default PIO word write function. Doesn't perform real outw.
****************************************************************************/
static void X86API p_outw(
	X86EMU_pioAddr addr,
	u16 val)
{
DB(	if (DEBUG_IO_TRACE())
		printk("outw %#04x -> %#04x \n", val, addr);)
	return;
}

/****************************************************************************
PARAMETERS:
addr	- PIO address to write
val     - Value to store
REMARKS:
Default PIO ;ong write function. Doesn't perform real outl.
****************************************************************************/
static void X86API p_outl(
	X86EMU_pioAddr addr,
	u32 val)
{
DB(	if (DEBUG_IO_TRACE())
		printk("outl %#08x -> %#04x \n", val, addr);)
    return;
}

/*------------------------- Global Variables ------------------------------*/

u8  	(X86APIP sys_rdb)(u32 addr) 			            = rdb;
u16 	(X86APIP sys_rdw)(u32 addr) 			            = rdw;
u32 	(X86APIP sys_rdl)(u32 addr) 			            = rdl;
void 	(X86APIP sys_wrb)(u32 addr,u8 val) 		            = wrb;
void 	(X86APIP sys_wrw)(u32 addr,u16 val) 	            = wrw;
void 	(X86APIP sys_wrl)(u32 addr,u32 val) 	            = wrl;
u8  	(X86APIP sys_inb)(X86EMU_pioAddr addr)	            = p_inb;
u16 	(X86APIP sys_inw)(X86EMU_pioAddr addr)	            = p_inw;
u32 	(X86APIP sys_inl)(X86EMU_pioAddr addr)              = p_inl;
void 	(X86APIP sys_outb)(X86EMU_pioAddr addr, u8 val) 	= p_outb;
void 	(X86APIP sys_outw)(X86EMU_pioAddr addr, u16 val)	= p_outw;
void 	(X86APIP sys_outl)(X86EMU_pioAddr addr, u32 val)	= p_outl;

/*----------------------------- Setup -------------------------------------*/

/****************************************************************************
PARAMETERS:
funcs	- New memory function pointers to make active

REMARKS:
This function is used to set the pointers to functions which access
memory space, allowing the user application to override these functions
and hook them out as necessary for their application.
****************************************************************************/
void X86EMU_setupMemFuncs(
	X86EMU_memFuncs *funcs)
{
    sys_rdb = funcs->rdb;
    sys_rdw = funcs->rdw;
    sys_rdl = funcs->rdl;
    sys_wrb = funcs->wrb;
    sys_wrw = funcs->wrw;
    sys_wrl = funcs->wrl;
}

/****************************************************************************
PARAMETERS:
funcs	- New programmed I/O function pointers to make active

REMARKS:
This function is used to set the pointers to functions which access
I/O space, allowing the user application to override these functions
and hook them out as necessary for their application.
****************************************************************************/
void X86EMU_setupPioFuncs(
	X86EMU_pioFuncs *funcs)
{
    sys_inb = funcs->inb;
    sys_inw = funcs->inw;
    sys_inl = funcs->inl;
    sys_outb = funcs->outb;
    sys_outw = funcs->outw;
    sys_outl = funcs->outl;
}

/****************************************************************************
PARAMETERS:
funcs	- New interrupt vector table to make active

REMARKS:
This function is used to set the pointers to functions which handle
interrupt processing in the emulator, allowing the user application to
hook interrupts as necessary for their application. Any interrupts that
are not hooked by the user application, and reflected and handled internally
in the emulator via the interrupt vector table. This allows the application
to get control when the code being emulated executes specific software
interrupts.
****************************************************************************/
void X86EMU_setupIntrFuncs(
	X86EMU_intrFuncs funcs[])
{
    int i;
    
	for (i=0; i < 256; i++)
		_X86EMU_intrTab[i] = NULL;
	if (funcs) {
		for (i = 0; i < 256; i++)
			_X86EMU_intrTab[i] = funcs[i];
		}
}

/****************************************************************************
PARAMETERS:
int	- New software interrupt to prepare for

REMARKS:
This function is used to set up the emulator state to exceute a software
interrupt. This can be used by the user application code to allow an
interrupt to be hooked, examined and then reflected back to the emulator
so that the code in the emulator will continue processing the software
interrupt as per normal. This essentially allows system code to actively
hook and handle certain software interrupts as necessary.
****************************************************************************/
void X86EMU_prepareForInt(
	int num)
{
    push_word((u16)M.x86.R_FLG);
    CLEAR_FLAG(F_IF);
    CLEAR_FLAG(F_TF);
    push_word(M.x86.R_CS);
    M.x86.R_CS = mem_access_word(num * 4 + 2);
    push_word(M.x86.R_IP);
    M.x86.R_IP = mem_access_word(num * 4);
	M.x86.intr = 0;
}
Commit	Line	Data
a6316ce4 MT	1	/****************************************************************************
	2	*
	3	* Realmode X86 Emulator Library
	4	*
	5	* Copyright (C) 1996-1999 SciTech Software, Inc.
	6	* Copyright (C) David Mosberger-Tang
	7	* Copyright (C) 1999 Egbert Eich
	8	*
	9	* ========================================================================
	10	*
	11	* Permission to use, copy, modify, distribute, and sell this software and
	12	* its documentation for any purpose is hereby granted without fee,
	13	* provided that the above copyright notice appear in all copies and that
	14	* both that copyright notice and this permission notice appear in
	15	* supporting documentation, and that the name of the authors not be used
	16	* in advertising or publicity pertaining to distribution of the software
	17	* without specific, written prior permission. The authors makes no
	18	* representations about the suitability of this software for any purpose.
	19	* It is provided "as is" without express or implied warranty.
	20	*
	21	* THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
	22	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
	23	* EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
	24	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
	25	* USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
	26	* OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
	27	* PERFORMANCE OF THIS SOFTWARE.
	28	*
	29	* ========================================================================
	30	*
	31	* Language: ANSI C
	32	* Environment: Any
	33	* Developer: Kendall Bennett
	34	*
	35	* Description: This file includes subroutines which are related to
	36	* programmed I/O and memory access. Included in this module
	37	* are default functions with limited usefulness. For real
	38	* uses these functions will most likely be overriden by the
	39	* user library.
	40	*
	41	****************************************************************************/
	42	/* $XFree86: xc/extras/x86emu/src/x86emu/sys.c,v 1.6 2002/09/16 18:05:18 eich Exp $ */
	43
	44	#include "x86emu.h"
	45	#include "x86emu/x86emui.h"
	46	#include "x86emu/regs.h"
	47	#include "x86emu/debug.h"
	48	#include "x86emu/prim_ops.h"
	49	#ifdef IN_MODULE
	50	#include "xf86_ansic.h"
	51	#else
	52	#include <string.h>
	53	#endif
	54	/------------------------- Global Variables ------------------------------/
	55
	56	X86EMU_sysEnv _X86EMU_env; /* Global emulator machine state */
	57	X86EMU_intrFuncs _X86EMU_intrTab[256];
	58
	59	/----------------------------- Implementation ----------------------------/
	60	#if defined(__alpha__) \|\| defined(__alpha)
	61	/* to cope with broken egcs-1.1.2 :-(((( */
	62
	63	#define ALPHA_UALOADS
	64	/*
65	* inline functions to do unaligned accesses
66	* from linux/include/asm-alpha/unaligned.h
67	*/
68
69	/*
70	* EGCS 1.1 knows about arbitrary unaligned loads. Define some
71	* packed structures to talk about such things with.
72	*/
73
74	#if defined(__GNUC__) && ((__GNUC__ > 2) \|\| (__GNUC_MINOR__ >= 91))
75	struct __una_u64 { unsigned long x __attribute__((packed)); };
76	struct __una_u32 { unsigned int x __attribute__((packed)); };
77	struct __una_u16 { unsigned short x __attribute__((packed)); };
78	#endif
79
80	static __inline__ unsigned long ldq_u(unsigned long * r11)
81	{
82	#if defined(__GNUC__) && ((__GNUC__ > 2) \|\| (__GNUC_MINOR__ >= 91))
83	const struct __una_u64 ptr = (const struct __una_u64 ) r11;
84	return ptr->x;
85	#else
86	unsigned long r1,r2;
87	__asm__("ldq_u %0,%3\n\t"
88	"ldq_u %1,%4\n\t"
89	"extql %0,%2,%0\n\t"
90	"extqh %1,%2,%1"
91	:"=&r" (r1), "=&r" (r2)
92	:"r" (r11),
93	"m" (*r11),
94	"m" ((const unsigned long )(7+(char *) r11)));
95	return r1 \| r2;
96	#endif
97	}
98
99	static __inline__ unsigned long ldl_u(unsigned int * r11)
100	{
101	#if defined(__GNUC__) && ((__GNUC__ > 2) \|\| (__GNUC_MINOR__ >= 91))
102	const struct __una_u32 ptr = (const struct __una_u32 ) r11;
103	return ptr->x;
104	#else
105	unsigned long r1,r2;
106	__asm__("ldq_u %0,%3\n\t"
107	"ldq_u %1,%4\n\t"
108	"extll %0,%2,%0\n\t"
109	"extlh %1,%2,%1"
110	:"=&r" (r1), "=&r" (r2)
111	:"r" (r11),
112	"m" (*r11),
113	"m" ((const unsigned long )(3+(char *) r11)));
114	return r1 \| r2;
115	#endif
116	}
117
118	static __inline__ unsigned long ldw_u(unsigned short * r11)
119	{
120	#if defined(__GNUC__) && ((__GNUC__ > 2) \|\| (__GNUC_MINOR__ >= 91))
121	const struct __una_u16 ptr = (const struct __una_u16 ) r11;
122	return ptr->x;
123	#else
124	unsigned long r1,r2;
125	__asm__("ldq_u %0,%3\n\t"
126	"ldq_u %1,%4\n\t"
127	"extwl %0,%2,%0\n\t"
128	"extwh %1,%2,%1"
129	:"=&r" (r1), "=&r" (r2)
130	:"r" (r11),
131	"m" (*r11),
132	"m" ((const unsigned long )(1+(char *) r11)));
133	return r1 \| r2;
134	#endif
135	}
136
137	/*
138	* Elemental unaligned stores
139	*/
140
141	static __inline__ void stq_u(unsigned long r5, unsigned long * r11)
142	{
143	#if defined(__GNUC__) && ((__GNUC__ > 2) \|\| (__GNUC_MINOR__ >= 91))
144	struct __una_u64 ptr = (struct __una_u64 ) r11;
145	ptr->x = r5;
146	#else
147	unsigned long r1,r2,r3,r4;
148
149	__asm__("ldq_u %3,%1\n\t"
150	"ldq_u %2,%0\n\t"
151	"insqh %6,%7,%5\n\t"
152	"insql %6,%7,%4\n\t"
153	"mskqh %3,%7,%3\n\t"
154	"mskql %2,%7,%2\n\t"
155	"bis %3,%5,%3\n\t"
156	"bis %2,%4,%2\n\t"
157	"stq_u %3,%1\n\t"
158	"stq_u %2,%0"
159	:"=m" (*r11),
160	"=m" ((unsigned long )(7+(char *) r11)),
161	"=&r" (r1), "=&r" (r2), "=&r" (r3), "=&r" (r4)
162	:"r" (r5), "r" (r11));
163	#endif
164	}
165
166	static __inline__ void stl_u(unsigned long r5, unsigned int * r11)
167	{
168	#if defined(__GNUC__) && ((__GNUC__ > 2) \|\| (__GNUC_MINOR__ >= 91))
169	struct __una_u32 ptr = (struct __una_u32 ) r11;
170	ptr->x = r5;
171	#else
172	unsigned long r1,r2,r3,r4;
173
174	__asm__("ldq_u %3,%1\n\t"
175	"ldq_u %2,%0\n\t"
176	"inslh %6,%7,%5\n\t"
177	"insll %6,%7,%4\n\t"
178	"msklh %3,%7,%3\n\t"
179	"mskll %2,%7,%2\n\t"
180	"bis %3,%5,%3\n\t"
181	"bis %2,%4,%2\n\t"
182	"stq_u %3,%1\n\t"
183	"stq_u %2,%0"
184	:"=m" (*r11),
185	"=m" ((unsigned long )(3+(char *) r11)),
186	"=&r" (r1), "=&r" (r2), "=&r" (r3), "=&r" (r4)
187	:"r" (r5), "r" (r11));
188	#endif
189	}
190
191	static __inline__ void stw_u(unsigned long r5, unsigned short * r11)
192	{
193	#if defined(__GNUC__) && ((__GNUC__ > 2) \|\| (__GNUC_MINOR__ >= 91))
194	struct __una_u16 ptr = (struct __una_u16 ) r11;
195	ptr->x = r5;
196	#else
197	unsigned long r1,r2,r3,r4;
198
199	__asm__("ldq_u %3,%1\n\t"
200	"ldq_u %2,%0\n\t"
201	"inswh %6,%7,%5\n\t"
202	"inswl %6,%7,%4\n\t"
203	"mskwh %3,%7,%3\n\t"
204	"mskwl %2,%7,%2\n\t"
205	"bis %3,%5,%3\n\t"
206	"bis %2,%4,%2\n\t"
207	"stq_u %3,%1\n\t"
208	"stq_u %2,%0"
209	:"=m" (*r11),
210	"=m" ((unsigned long )(1+(char *) r11)),
211	"=&r" (r1), "=&r" (r2), "=&r" (r3), "=&r" (r4)
212	:"r" (r5), "r" (r11));
213	#endif
214	}
215
216	#elif defined(__GNUC__) && ((__GNUC__ < 3)) && \
217	(defined (__ia64__) \|\| defined (ia64__))
218	#define IA64_UALOADS
219	/*
220	* EGCS 1.1 knows about arbitrary unaligned loads. Define some
221	* packed structures to talk about such things with.
222	*/
223	struct __una_u64 { unsigned long x __attribute__((packed)); };
224	struct __una_u32 { unsigned int x __attribute__((packed)); };
225	struct __una_u16 { unsigned short x __attribute__((packed)); };
226
227	static __inline__ unsigned long
228	__uldq (const unsigned long * r11)
229	{
230	const struct __una_u64 ptr = (const struct __una_u64 ) r11;
231	return ptr->x;
232	}
233
234	static __inline__ unsigned long
235	uldl (const unsigned int * r11)
236	{
237	const struct __una_u32 ptr = (const struct __una_u32 ) r11;
238	return ptr->x;
239	}
240
241	static __inline__ unsigned long
242	uldw (const unsigned short * r11)
243	{
244	const struct __una_u16 ptr = (const struct __una_u16 ) r11;
245	return ptr->x;
246	}
247
248	static __inline__ void
249	ustq (unsigned long r5, unsigned long * r11)
250	{
251	struct __una_u64 ptr = (struct __una_u64 ) r11;
252	ptr->x = r5;
253	}
254
255	static __inline__ void
256	ustl (unsigned long r5, unsigned int * r11)
257	{
258	struct __una_u32 ptr = (struct __una_u32 ) r11;
259	ptr->x = r5;
260	}
261
262	static __inline__ void
263	ustw (unsigned long r5, unsigned short * r11)
264	{
265	struct __una_u16 ptr = (struct __una_u16 ) r11;
266	ptr->x = r5;
267	}
268
269	#endif
270
271	/****************************************************************************
272	PARAMETERS:
273	addr - Emulator memory address to read
274
275	RETURNS:
276	Byte value read from emulator memory.
277
278	REMARKS:
279	Reads a byte value from the emulator memory.
280	****************************************************************************/
281	u8 X86API rdb(
282	u32 addr)
283	{
284	u8 val;
285
286	if (addr > M.mem_size - 1) {
287	DB(printk("mem_read: address %#lx out of range!\n", addr);)
288	HALT_SYS();
289	}
290	val = (u8)(M.mem_base + addr);
291	DB( if (DEBUG_MEM_TRACE())
292	printk("%#08x 1 -> %#x\n", addr, val);)
293	return val;
294	}
295
296	/****************************************************************************
297	PARAMETERS:
298	addr - Emulator memory address to read
299
300	RETURNS:
301	Word value read from emulator memory.
302
303	REMARKS:
304	Reads a word value from the emulator memory.
305	****************************************************************************/
306	u16 X86API rdw(
307	u32 addr)
308	{
309	u16 val = 0;
310
311	if (addr > M.mem_size - 2) {
312	DB(printk("mem_read: address %#lx out of range!\n", addr);)
313	HALT_SYS();
314	}
315	#ifdef __BIG_ENDIAN__
316	if (addr & 0x1) {
317	val = ((u8)(M.mem_base + addr) \|
318	((u8)(M.mem_base + addr + 1) << 8));
319	}
320	else
321	#endif
322	#if defined(ALPHA_UALOADS)
323	val = ldw_u((u16*)(M.mem_base + addr));
324	#elif defined(IA64_UALOADS)
325	val = uldw((u16*)(M.mem_base + addr));
326	#else
327	val = (u16)(M.mem_base + addr);
328	#endif
329	DB( if (DEBUG_MEM_TRACE())
330	printk("%#08x 2 -> %#x\n", addr, val);)
331	return val;
332	}
333
334	/****************************************************************************
335	PARAMETERS:
336	addr - Emulator memory address to read
337
338	RETURNS:
339	Long value read from emulator memory.
340	REMARKS:
341	Reads a long value from the emulator memory.
342	****************************************************************************/
343	u32 X86API rdl(
344	u32 addr)
345	{
346	u32 val = 0;
347
348	if (addr > M.mem_size - 4) {
349	DB(printk("mem_read: address %#lx out of range!\n", addr);)
350	HALT_SYS();
351	}
352	#ifdef __BIG_ENDIAN__
353	if (addr & 0x3) {
354	val = ((u8)(M.mem_base + addr + 0) \|
355	((u8)(M.mem_base + addr + 1) << 8) \|
356	((u8)(M.mem_base + addr + 2) << 16) \|
357	((u8)(M.mem_base + addr + 3) << 24));
358	}
359	else
360	#endif
361	#if defined(ALPHA_UALOADS)
362	val = ldl_u((u32*)(M.mem_base + addr));
363	#elif defined(IA64_UALOADS)
364	val = uldl((u32*)(M.mem_base + addr));
365	#else
366	val = (u32)(M.mem_base + addr);
367	#endif
368	DB( if (DEBUG_MEM_TRACE())
369	printk("%#08x 4 -> %#x\n", addr, val);)
370	return val;
371	}
372
373	/****************************************************************************
374	PARAMETERS:
375	addr - Emulator memory address to read
376	val - Value to store
377
378	REMARKS:
379	Writes a byte value to emulator memory.
380	****************************************************************************/
381	void X86API wrb(
382	u32 addr,
383	u8 val)
384	{
385	DB( if (DEBUG_MEM_TRACE())
386	printk("%#08x 1 <- %#x\n", addr, val);)
387	if (addr > M.mem_size - 1) {
388	DB(printk("mem_write: address %#lx out of range!\n", addr);)
389	HALT_SYS();
390	}
391	(u8)(M.mem_base + addr) = val;
392	}
393
394	/****************************************************************************
395	PARAMETERS:
396	addr - Emulator memory address to read
397	val - Value to store
398
399	REMARKS:
400	Writes a word value to emulator memory.
401	****************************************************************************/
402	void X86API wrw(
403	u32 addr,
404	u16 val)
405	{
406	DB( if (DEBUG_MEM_TRACE())
407	printk("%#08x 2 <- %#x\n", addr, val);)
408	if (addr > M.mem_size - 2) {
409	DB(printk("mem_write: address %#lx out of range!\n", addr);)
410	HALT_SYS();
411	}
412	#ifdef __BIG_ENDIAN__
413	if (addr & 0x1) {
414	(u8)(M.mem_base + addr + 0) = (val >> 0) & 0xff;
415	(u8)(M.mem_base + addr + 1) = (val >> 8) & 0xff;
416	}
417	else
418	#endif
419	#if defined(ALPHA_UALOADS)
420	stw_u(val,(u16*)(M.mem_base + addr));
421	#elif defined(IA64_UALOADS)
422	ustw(val,(u16*)(M.mem_base + addr));
423	#else
424	(u16)(M.mem_base + addr) = val;
425	#endif
426	}
427
428	/****************************************************************************
429	PARAMETERS:
430	addr - Emulator memory address to read
431	val - Value to store
432
433	REMARKS:
434	Writes a long value to emulator memory.
435	****************************************************************************/
436	void X86API wrl(
437	u32 addr,
438	u32 val)
439	{
440	DB( if (DEBUG_MEM_TRACE())
441	printk("%#08x 4 <- %#x\n", addr, val);)
442	if (addr > M.mem_size - 4) {
443	DB(printk("mem_write: address %#lx out of range!\n", addr);)
444	HALT_SYS();
445	}
446	#ifdef __BIG_ENDIAN__
447	if (addr & 0x1) {
448	(u8)(M.mem_base + addr + 0) = (val >> 0) & 0xff;
449	(u8)(M.mem_base + addr + 1) = (val >> 8) & 0xff;
450	(u8)(M.mem_base + addr + 2) = (val >> 16) & 0xff;
451	(u8)(M.mem_base + addr + 3) = (val >> 24) & 0xff;
452	}
453	else
454	#endif
455	#if defined(ALPHA_UALOADS)
456	stl_u(val,(u32*)(M.mem_base + addr));
457	#elif defined(IA64_UALOADS)
458	ustl(val,(u32*)(M.mem_base + addr));
459	#else
460	(u32)(M.mem_base + addr) = val;
461	#endif
462	}
463
464	/****************************************************************************
465	PARAMETERS:
466	addr - PIO address to read
467	RETURN:
468	0
469	REMARKS:
470	Default PIO byte read function. Doesn't perform real inb.
471	****************************************************************************/
472	static u8 X86API p_inb(
473	X86EMU_pioAddr addr)
474	{
475	DB( if (DEBUG_IO_TRACE())
476	printk("inb %#04x \n", addr);)
477	return 0;
478	}
479
480	/****************************************************************************
481	PARAMETERS:
482	addr - PIO address to read
483	RETURN:
484	0
485	REMARKS:
486	Default PIO word read function. Doesn't perform real inw.
487	****************************************************************************/
488	static u16 X86API p_inw(
489	X86EMU_pioAddr addr)
490	{
491	DB( if (DEBUG_IO_TRACE())
492	printk("inw %#04x \n", addr);)
493	return 0;
494	}
495
496	/****************************************************************************
497	PARAMETERS:
498	addr - PIO address to read
499	RETURN:
500	0
501	REMARKS:
502	Default PIO long read function. Doesn't perform real inl.
503	****************************************************************************/
504	static u32 X86API p_inl(
505	X86EMU_pioAddr addr)
506	{
507	DB( if (DEBUG_IO_TRACE())
508	printk("inl %#04x \n", addr);)
509	return 0;
510	}
511
512	/****************************************************************************
513	PARAMETERS:
514	addr - PIO address to write
515	val - Value to store
516	REMARKS:
517	Default PIO byte write function. Doesn't perform real outb.
518	****************************************************************************/
519	static void X86API p_outb(
520	X86EMU_pioAddr addr,
521	u8 val)
522	{
523	DB( if (DEBUG_IO_TRACE())
524	printk("outb %#02x -> %#04x \n", val, addr);)
525	return;
526	}
527
528	/****************************************************************************
529	PARAMETERS:
530	addr - PIO address to write
531	val - Value to store
532	REMARKS:
533	Default PIO word write function. Doesn't perform real outw.
534	****************************************************************************/
535	static void X86API p_outw(
536	X86EMU_pioAddr addr,
537	u16 val)
538	{
539	DB( if (DEBUG_IO_TRACE())
540	printk("outw %#04x -> %#04x \n", val, addr);)
541	return;
542	}
543
544	/****************************************************************************
545	PARAMETERS:
546	addr - PIO address to write
547	val - Value to store
548	REMARKS:
549	Default PIO ;ong write function. Doesn't perform real outl.
550	****************************************************************************/
551	static void X86API p_outl(
552	X86EMU_pioAddr addr,
553	u32 val)
554	{
555	DB( if (DEBUG_IO_TRACE())
556	printk("outl %#08x -> %#04x \n", val, addr);)
557	return;
558	}
559
560	/------------------------- Global Variables ------------------------------/
561
562	u8 (X86APIP sys_rdb)(u32 addr) = rdb;
563	u16 (X86APIP sys_rdw)(u32 addr) = rdw;
564	u32 (X86APIP sys_rdl)(u32 addr) = rdl;
565	void (X86APIP sys_wrb)(u32 addr,u8 val) = wrb;
566	void (X86APIP sys_wrw)(u32 addr,u16 val) = wrw;
567	void (X86APIP sys_wrl)(u32 addr,u32 val) = wrl;
568	u8 (X86APIP sys_inb)(X86EMU_pioAddr addr) = p_inb;
569	u16 (X86APIP sys_inw)(X86EMU_pioAddr addr) = p_inw;
570	u32 (X86APIP sys_inl)(X86EMU_pioAddr addr) = p_inl;
571	void (X86APIP sys_outb)(X86EMU_pioAddr addr, u8 val) = p_outb;
572	void (X86APIP sys_outw)(X86EMU_pioAddr addr, u16 val) = p_outw;
573	void (X86APIP sys_outl)(X86EMU_pioAddr addr, u32 val) = p_outl;
574
575	/----------------------------- Setup -------------------------------------/
576
577	/****************************************************************************
578	PARAMETERS:
579	funcs - New memory function pointers to make active
580
581	REMARKS:
582	This function is used to set the pointers to functions which access
583	memory space, allowing the user application to override these functions
584	and hook them out as necessary for their application.
585	****************************************************************************/
586	void X86EMU_setupMemFuncs(
587	X86EMU_memFuncs *funcs)
588	{
589	sys_rdb = funcs->rdb;
590	sys_rdw = funcs->rdw;
591	sys_rdl = funcs->rdl;
592	sys_wrb = funcs->wrb;
593	sys_wrw = funcs->wrw;
594	sys_wrl = funcs->wrl;
595	}
596
597	/****************************************************************************
598	PARAMETERS:
599	funcs - New programmed I/O function pointers to make active
600
601	REMARKS:
602	This function is used to set the pointers to functions which access
603	I/O space, allowing the user application to override these functions
604	and hook them out as necessary for their application.
605	****************************************************************************/
606	void X86EMU_setupPioFuncs(
607	X86EMU_pioFuncs *funcs)
608	{
609	sys_inb = funcs->inb;
610	sys_inw = funcs->inw;
611	sys_inl = funcs->inl;
612	sys_outb = funcs->outb;
613	sys_outw = funcs->outw;
614	sys_outl = funcs->outl;
615	}
616
617	/****************************************************************************
618	PARAMETERS:
619	funcs - New interrupt vector table to make active
620
621	REMARKS:
622	This function is used to set the pointers to functions which handle
623	interrupt processing in the emulator, allowing the user application to
624	hook interrupts as necessary for their application. Any interrupts that
625	are not hooked by the user application, and reflected and handled internally
626	in the emulator via the interrupt vector table. This allows the application
627	to get control when the code being emulated executes specific software
628	interrupts.
629	****************************************************************************/
630	void X86EMU_setupIntrFuncs(
631	X86EMU_intrFuncs funcs[])
632	{
633	int i;
634
635	for (i=0; i < 256; i++)
636	_X86EMU_intrTab[i] = NULL;
637	if (funcs) {
638	for (i = 0; i < 256; i++)
639	_X86EMU_intrTab[i] = funcs[i];
640	}
641	}
642
643	/****************************************************************************
644	PARAMETERS:
645	int - New software interrupt to prepare for
646
647	REMARKS:
648	This function is used to set up the emulator state to exceute a software
649	interrupt. This can be used by the user application code to allow an
650	interrupt to be hooked, examined and then reflected back to the emulator
651	so that the code in the emulator will continue processing the software
652	interrupt as per normal. This essentially allows system code to actively
653	hook and handle certain software interrupts as necessary.
654	****************************************************************************/
655	void X86EMU_prepareForInt(
656	int num)
657	{
658	push_word((u16)M.x86.R_FLG);
659	CLEAR_FLAG(F_IF);
660	CLEAR_FLAG(F_TF);
661	push_word(M.x86.R_CS);
662	M.x86.R_CS = mem_access_word(num * 4 + 2);
663	push_word(M.x86.R_IP);
664	M.x86.R_IP = mem_access_word(num * 4);
665	M.x86.intr = 0;
666	}