path: root/src/lrmi/backend-x86emu.c

#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <pciaccess.h>

#include "x86emu.h"
#include "libx86.h"
#include "common.h"


xf86Int10InfoPtr Int10Current = NULL;

#define M _X86EMU_env

#define X86_EAX _X86EMU_env.x86.R_EAX
#define X86_EBX _X86EMU_env.x86.R_EBX
#define X86_ECX _X86EMU_env.x86.R_ECX
#define X86_EDX _X86EMU_env.x86.R_EDX
#define X86_ESI _X86EMU_env.x86.R_ESI
#define X86_EDI _X86EMU_env.x86.R_EDI
#define X86_EBP _X86EMU_env.x86.R_EBP
#define X86_EIP _X86EMU_env.x86.R_EIP
#define X86_ESP _X86EMU_env.x86.R_ESP
#define X86_EFLAGS _X86EMU_env.x86.R_EFLG

#define X86_FLAGS _X86EMU_env.x86.R_FLG
#define X86_AX _X86EMU_env.x86.R_AX
#define X86_BX _X86EMU_env.x86.R_BX
#define X86_CX _X86EMU_env.x86.R_CX
#define X86_DX _X86EMU_env.x86.R_DX
#define X86_SI _X86EMU_env.x86.R_SI
#define X86_DI _X86EMU_env.x86.R_DI
#define X86_BP _X86EMU_env.x86.R_BP
#define X86_IP _X86EMU_env.x86.R_IP
#define X86_SP _X86EMU_env.x86.R_SP
#define X86_CS _X86EMU_env.x86.R_CS
#define X86_DS _X86EMU_env.x86.R_DS
#define X86_ES _X86EMU_env.x86.R_ES
#define X86_SS _X86EMU_env.x86.R_SS
#define X86_FS _X86EMU_env.x86.R_FS
#define X86_GS _X86EMU_env.x86.R_GS

#define X86_AL _X86EMU_env.x86.R_AL
#define X86_BL _X86EMU_env.x86.R_BL
#define X86_CL _X86EMU_env.x86.R_CL
#define X86_DL _X86EMU_env.x86.R_DL

#define X86_AH _X86EMU_env.x86.R_AH
#define X86_BH _X86EMU_env.x86.R_BH
#define X86_CH _X86EMU_env.x86.R_CH
#define X86_DH _X86EMU_env.x86.R_DH


#define CARD8  unsigned char
#define CARD16 unsigned short
#define CARD32 unsigned long
#define pointer void *
#define IOADDRESS void *
#define Bool int

#define X86_TF_MASK             0x00000100
#define X86_IF_MASK             0x00000200
#define X86_IOPL_MASK           0x00003000
#define X86_NT_MASK             0x00004000
#define X86_VM_MASK             0x00020000
#define X86_AC_MASK             0x00040000
#define X86_VIF_MASK            0x00080000      /* virtual interrupt flag */
#define X86_VIP_MASK            0x00100000      /* virtual interrupt pending */
#define X86_ID_MASK             0x00200000

#define MEM_RB(name, addr)      (*name->mem->rb)(name, addr)
#define MEM_RW(name, addr)      (*name->mem->rw)(name, addr)
#define MEM_RL(name, addr)      (*name->mem->rl)(name, addr)
#define MEM_WB(name, addr, val) (*name->mem->wb)(name, addr, val)
#define MEM_WW(name, addr, val) (*name->mem->ww)(name, addr, val)
#define MEM_WL(name, addr, val) (*name->mem->wl)(name, addr, val)


#define SHMERRORPTR (pointer)(-1)

#define __BUILDIO(bwl,bw,type) \
static inline void out##bwl##_local(unsigned long port, unsigned type value) {        __asm__ __volatile__("out" #bwl " %" #bw "0, %w1" : : "a"(value), "Nd"(port)); \
}\
static inline unsigned type in##bwl##_local(unsigned long port) { \
        unsigned type value; \
        __asm__ __volatile__("in" #bwl " %w1, %" #bw "0" : "=a"(value) : "Nd"(port)); \
        return value; \
}\

__BUILDIO(b,b,char)
__BUILDIO(w,w,short)
__BUILDIO(l,,int)


char *mmap_addr = SHMERRORPTR;
static void *stack;

/*
 * the emulator cannot pass a pointer to the current xf86Int10InfoRec
 * to the memory access functions therefore store it here.
 */

typedef struct {
    int shift;
    int entries;
    void* base;
    void* vRam;
    int highMemory;
    void* sysMem;
    char* alloc;
} genericInt10Priv;

#define INTPriv(x) ((genericInt10Priv*)x->private)

void
printk(const char *fmt, ...)
{
	va_list argptr;
	va_start(argptr, fmt);

	fprintf(stderr, fmt, argptr);
	va_end(argptr);
}

#define OFF(addr) ((addr) & 0xffff)
# define HIGH_OFFSET (INTPriv(pInt)->highMemory)
# define HIGH_BASE   V_BIOS
# define SYS(addr) ((addr) >= HIGH_OFFSET)
#define V_ADDR(addr) \
      (SYS(addr) ? ((char*)INTPriv(pInt)->sysMem) + (addr - HIGH_BASE) \
       : (((char*)(INTPriv(pInt)->base) + addr)))

#define V_ADDR_RB(addr) *(CARD8*) V_ADDR(addr)
//#define V_ADDR_RW(addr) ldw_u((pointer)V_ADDR(addr))
//#define V_ADDR_RL(addr) ldl_u((pointer)V_ADDR(addr))

#define V_ADDR_WB(addr,val) *(CARD8*) V_ADDR(addr) = val;
//#define V_ADDR_WW(addr,val) stw_u((val),(pointer)(V_ADDR(addr)));
//#define V_ADDR_WL(addr,val) stl_u(val,(pointer)(V_ADDR(addr)));

static CARD8
read_b(xf86Int10InfoPtr pInt, int addr)
{
    return V_ADDR_RB(addr);
}

static CARD16
read_w(xf86Int10InfoPtr pInt, int addr)
{
#if 0
X_BYTE_ORDER == X_LITTLE_ENDIAN
    if (OFF(addr + 1) > 0)
    return V_ADDR_RW(addr);
#endif
    return V_ADDR_RB(addr) | (V_ADDR_RB(addr + 1) << 8);
}

static CARD32
read_l(xf86Int10InfoPtr pInt, int addr)
{
#if 0
X_BYTE_ORDER == X_LITTLE_ENDIAN
    if (OFF(addr + 3) > 2)
    return V_ADDR_RL(addr);
#endif
    return V_ADDR_RB(addr) |
       (V_ADDR_RB(addr + 1) << 8) |
       (V_ADDR_RB(addr + 2) << 16) |
       (V_ADDR_RB(addr + 3) << 24);
}

static void
write_b(xf86Int10InfoPtr pInt, int addr, CARD8 val)
{
    V_ADDR_WB(addr,val);
}

static void
write_w(xf86Int10InfoPtr pInt, int addr, CARD16 val)
{
#if 0
X_BYTE_ORDER == X_LITTLE_ENDIAN
    if (OFF(addr + 1) > 0)
      { V_ADDR_WW(addr, val); }
#endif
    V_ADDR_WB(addr, val);
    V_ADDR_WB(addr + 1, val >> 8);
}

static void
write_l(xf86Int10InfoPtr pInt, int addr, CARD32 val)
{
#if 0
X_BYTE_ORDER == X_LITTLE_ENDIAN
    if (OFF(addr + 3) > 2)
      { V_ADDR_WL(addr, val); }
#endif
    V_ADDR_WB(addr, val);
    V_ADDR_WB(addr + 1, val >> 8);
    V_ADDR_WB(addr + 2, val >> 16);
    V_ADDR_WB(addr + 3, val >> 24);
}

static int10MemRec genericMem = {
    read_b,
    read_w,
    read_l,
    write_b,
    write_w,
    write_l
};

void *
LRMI_base_addr(xf86Int10InfoPtr pInt, CARD32 addr)
{
    return V_ADDR(addr);
}

static CARD8
x_inb(CARD16 port)
{
    CARD8 val;

    val = inb_local(Int10Current->ioBase + port);
    return val;
}

static CARD16
x_inw(CARD16 port)
{
    CARD16 val;

    val = inw_local(Int10Current->ioBase + port);

    return val;
}

static CARD32
x_inl(CARD16 port)
{
    CARD32 val;

    val = inl_local(Int10Current->ioBase + port);
    return val;
}

static void
x_outl(CARD16 port, CARD32 val)
{
    outl_local(Int10Current->ioBase + port, val);
}

static void
x_outb(CARD16 port, CARD8 val)
{
    outb_local(Int10Current->ioBase + port, val);
}

static void
x_outw(CARD16 port, CARD16 val)
{
    outw_local(Int10Current->ioBase + port, val);
}

static CARD8
Mem_rb(CARD32 addr)
{
    return (*Int10Current->mem->rb)(Int10Current, addr);
}

static CARD16
Mem_rw(CARD32 addr)
{
    return (*Int10Current->mem->rw)(Int10Current, addr);
}

static CARD32
Mem_rl(CARD32 addr)
{
    return (*Int10Current->mem->rl)(Int10Current, addr);
}

static void
Mem_wb(CARD32 addr, CARD8 val)
{
    (*Int10Current->mem->wb)(Int10Current, addr, val);
}

static void
Mem_ww(CARD32 addr, CARD16 val)
{
    (*Int10Current->mem->ww)(Int10Current, addr, val);
}

static void
Mem_wl(CARD32 addr, CARD32 val)
{
    (*Int10Current->mem->wl)(Int10Current, addr, val);
}

static void
pushw(xf86Int10InfoPtr pInt, CARD16 val)
{
    X86_ESP -= 2;
    MEM_WW(pInt, ((CARD32) X86_SS << 4) + X86_SP, val);
}

static int
run_bios_int(int num, xf86Int10InfoPtr pInt)
{
    CARD32 eflags;
    eflags = X86_EFLAGS;
    pushw(pInt, eflags);
    pushw(pInt, X86_CS);
    pushw(pInt, X86_IP);
    X86_CS = MEM_RW(pInt, (num << 2) + 2);
    X86_IP = MEM_RW(pInt,  num << 2);
    return 1;
}

static void
x86emu_do_int(int num)
{
    Int10Current->num = num;

    run_bios_int(num, Int10Current);
}

static int
intE6_handler(xf86Int10InfoPtr pInt)
{
    struct pci_device * pvp;
    pvp = pInt->dev;

    int a = pvp->bus;

    if (pvp)
        X86_AX = (pvp->bus << 8) | (pvp->dev << 3) | (pvp->func & 0x7);

    pushw(pInt, X86_CS);
    pushw(pInt, X86_IP);
    X86_CS = pInt->BIOSseg;
    X86_EIP = 0x0003;
    X86_ES = 0;                  /* standard pc es */
    return 1;
}

void
LRMI_int(xf86Int10InfoPtr pInt)
{
    int num = pInt->num;
    int ret = 0;

    switch (num) {
    case 0xe6:
    ret = intE6_handler(pInt);
    break;
    default:
    break;
    }

    if (!ret)
    ret = run_bios_int(num, pInt);

    if (!ret) {
    fprintf(stderr, "Halting on int 0x%2.2x!\n", num);
    }

    X86EMU_exec();
}

void
LRMI_setup(xf86Int10InfoPtr pInt)
{
    int i;
    X86EMU_intrFuncs intFuncs[256];
    X86EMU_pioFuncs pioFuncs = {
    (&x_inb),
    (&x_inw),
    (&x_inl),
    (&x_outb),
    (&x_outw),
    (&x_outl)
    };

    X86EMU_memFuncs memFuncs = {
    (&Mem_rb),
    (&Mem_rw),
    (&Mem_rl),
    (&Mem_wb),
    (&Mem_ww),
    (&Mem_wl)
    };

    X86EMU_setupMemFuncs(&memFuncs);

    M.mem_base = 0;
    M.mem_size = 1024*1024 + 1024;
    X86EMU_setupPioFuncs(&pioFuncs);

    for (i=0;i<256;i++)
    intFuncs[i] = x86emu_do_int;
    X86EMU_setupIntrFuncs(intFuncs);

    pInt->mem = &genericMem;
}

void
LRMI_set_exit_condition(xf86Int10InfoPtr pInt)
{
    /*
     * Here we set the exit condition:  We return when we encounter
     * 'hlt' (=0xf4), which we locate at address 0x600 in x86 memory.
     */
    MEM_WB(pInt, 0x0600, 0xf4);
}

int LRMI_init() {
#if 0
	int i;

	if (!LRMI_common_init())
		return 0;

	mmap_addr = 0;
	X86_EFLAGS = X86_IF_MASK | X86_IOPL_MASK;

	/*
	 * Allocate a 64k stack.
	 */
	stack = LRMI_alloc_real(64 * 1024);
	X86_SS = (unsigned int) stack >> 4;
	X86_ESP = 0xFFF9;
	memset (stack, 0, 64*1024);

	*((char *)0) = 0xf4; /* Make sure that we end up jumping back to a
				halt instruction */
	return 1;
#endif
}

void
LRMI_setup_int(xf86Int10InfoPtr pInt)
{
    Int10Current = pInt;
    X86_EAX = (CARD32) pInt->ax;
    X86_EBX = (CARD32) pInt->bx;
    X86_ECX = (CARD32) pInt->cx;
    X86_EDX = (CARD32) pInt->dx;
    X86_ESI = (CARD32) pInt->si;
    X86_EDI = (CARD32) pInt->di;
    X86_EBP = (CARD32) pInt->bp;
    X86_ESP = 0x1000; X86_SS = pInt->stackseg >> 4;
    X86_EIP = 0x0600; X86_CS = 0x0; /* address of 'hlt' */
    X86_DS = 0x40;          /* standard pc ds */
    X86_ES = pInt->es;
    X86_FS = 0;
    X86_GS = 0;
    X86_EFLAGS = X86_IF_MASK | X86_IOPL_MASK;
}

void
LRMI_finish_int(xf86Int10InfoPtr pInt)
{
    pInt->ax = (CARD32) X86_EAX;
    pInt->bx = (CARD32) X86_EBX;
    pInt->cx = (CARD32) X86_ECX;
    pInt->dx = (CARD32) X86_EDX;
    pInt->si = (CARD32) X86_ESI;
    pInt->di = (CARD32) X86_EDI;
    pInt->es = (CARD16) X86_ES;
    pInt->bp = (CARD32) X86_EBP;
    pInt->flags = (CARD32) X86_FLAGS;
}

void
LRMI_fini(xf86Int10InfoPtr pInt)
{
    if (Int10Current == pInt)
    Int10Current = NULL;
}