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

/*
Linux Real Mode Interface - A library of DPMI-like functions for Linux.

Copyright (C) 1998 by Josh Vanderhoof

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL JOSH VANDERHOOF BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
*/

#if defined(__i386__) && (defined(__linux__) || defined(__NetBSD__) \
    || defined(__FreeBSD__) || defined(__OpenBSD__))

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <inttypes.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>


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

#if defined(__linux__)
#define DEFAULT_VM86_FLAGS 	(IF_MASK | IOPL_MASK)
#elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
#define DEFAULT_VM86_FLAGS  (PSL_I | PSL_IOPL)
#endif
#define DEFAULT_STACK_SIZE 	0x1000

#ifdef __sparc__
#define DEV_MEM "/dev/fb"
#else
#define DEV_MEM "/dev/mem"
#endif
#define ALLOC_ENTRIES(x) ((V_RAM / x) - 1)
#define SHMERRORPTR (void *)(-1)

extern xf86Int10InfoPtr Int10Current;
static int counter = 0;

typedef struct {
    int lowMem;
    int highMem;
    char* base;
    char* base_high;
    int screen;
    char* alloc;
} linuxInt10Priv;


static uint8_t
read_b(xf86Int10InfoPtr pInt, int addr)
{
    return *((uint8_t *)addr);
}

static uint16_t
read_w(xf86Int10InfoPtr pInt, int addr)
{
    return *((uint16_t *)addr);
}

static uint32_t
read_l(xf86Int10InfoPtr pInt, int addr)
{
    return *((uint32_t *)addr);
}

static void
write_b(xf86Int10InfoPtr pInt, int addr, uint8_t val)
{
    *((uint8_t *)addr) = val;
}

static void
write_w(xf86Int10InfoPtr pInt, int addr, uint16_t val)
{
    *((uint16_t *)addr) = val;
}

static void
write_l(xf86Int10InfoPtr pInt, int addr, uint32_t val)
{
    *((uint32_t *)addr) = val;
}

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

static inline void
set_bit(unsigned int bit, void *array)
{
	unsigned char *a = array;

	a[bit / 8] |= (1 << (bit % 8));
}

void
LRMI_fini(xf86Int10InfoPtr pInt)
{
    if (!pInt)
    return;

    if (Int10Current == pInt) {
    shmdt(0);
    if (((linuxInt10Priv*)pInt->private)->highMem >= 0)
        shmdt((char*)HIGH_MEM);
    else
        munmap((void *)V_BIOS, (SYS_BIOS - V_BIOS));
    Int10Current = NULL;
    }
    
    if (((linuxInt10Priv*)pInt->private)->base_high)
    shmdt(((linuxInt10Priv*)pInt->private)->base_high);
    shmdt(((linuxInt10Priv*)pInt->private)->base);
    shmctl(((linuxInt10Priv*)pInt->private)->lowMem, IPC_RMID, NULL);
    if (((linuxInt10Priv*)pInt->private)->highMem >= 0)
    shmctl(((linuxInt10Priv*)pInt->private)->highMem, IPC_RMID, NULL);
    free(((linuxInt10Priv*)pInt->private)->alloc);
    free(pInt->private);
    free(pInt);
}

int
MapCurrentInt10(xf86Int10InfoPtr pInt)
{
    void *addr;
    int fd = -1;
    
    if (Int10Current) {
    shmdt(0);
    if (((linuxInt10Priv*)Int10Current->private)->highMem >= 0)
        shmdt((char*)HIGH_MEM);
    else
        munmap((void *)V_BIOS, (SYS_BIOS - V_BIOS));
    }
    addr = shmat(((linuxInt10Priv*)pInt->private)->lowMem, (char*)1, SHM_RND);
    if (addr == SHMERRORPTR) {
    fprintf(stderr, "Cannot shmat() low memory\n");
    fprintf(stderr, "shmat(low_mem) error: %s\n",strerror(errno));
    return 0;
    }
    if (mprotect((void*)0, V_RAM, PROT_READ|PROT_WRITE|PROT_EXEC) != 0)
        fprintf(stderr,
           "Cannot set EXEC bit on low memory: %s\n", strerror(errno));

    if (((linuxInt10Priv*)pInt->private)->highMem >= 0) {
    addr = shmat(((linuxInt10Priv*)pInt->private)->highMem,
             (char*)HIGH_MEM, 0);
    if (addr == SHMERRORPTR) {
        fprintf(stderr, "Cannot shmat() high memory\n");
        fprintf(stderr, "shmget error: %s\n",strerror(errno));
        return 0;
    }
    if (mprotect((void*)HIGH_MEM, HIGH_MEM_SIZE,
             PROT_READ|PROT_WRITE|PROT_EXEC) != 0)
        fprintf(stderr, "Cannot set EXEC bit on high memory: %s\n",
               strerror(errno));
    } else {
    if ((fd = open(DEV_MEM, O_RDWR, 0)) >= 0) {
        if (mmap((void *)(V_BIOS), SYS_BIOS - V_BIOS,
                 PROT_READ | PROT_WRITE | PROT_EXEC,
                 MAP_SHARED | MAP_FIXED, fd, V_BIOS)
        == MAP_FAILED) {
        fprintf(stderr, "Cannot map V_BIOS\n");
        close (fd);
        return 0;
        }
    } else {
        fprintf(stderr, "Cannot open %s\n",DEV_MEM);
        return 0;
    }
    close (fd);
    }
    
    return 1;
}

void
LRMI_init(xf86Int10InfoPtr pInt)
{
    int fd;
    static void* vidMem = NULL;
    static void* sysMem = NULL;
    void* vMem = NULL;
    int low_mem;
    int high_mem = -1;
    char *base = SHMERRORPTR;
    char *base_high = SHMERRORPTR;
    int videoBiosMapped = 0;


    /* TODO: should put this in common interface and to just run once instead
     * use the "hack" of static variables */
    if ((!vidMem) || (!sysMem)) {
    if ((fd = open(DEV_MEM, O_RDWR, 0)) >= 0) {
        if (!sysMem) {
        if ((sysMem = mmap((void *)(SYS_BIOS), BIOS_SIZE,
                   PROT_READ | PROT_EXEC,
                   MAP_SHARED | MAP_FIXED, fd, SYS_BIOS))
            == MAP_FAILED) {
            fprintf(stderr, "Cannot map SYS BIOS\n");
            close(fd);
            goto error;
        }
        }
        if (!vidMem) {
        if ((vidMem = mmap((void *)(V_RAM), VRAM_SIZE,
                   PROT_READ | PROT_WRITE | PROT_EXEC,
                   MAP_SHARED | MAP_FIXED, fd, V_RAM))
            == MAP_FAILED) {
            fprintf(stderr, "Cannot map V_RAM\n");
            close(fd);
            goto error;
        }
        }
        close(fd);
    } else {
        fprintf(stderr, "Cannot open %s\n", DEV_MEM);
        goto error;
    }
    }

    xxxf86Int10ExecSetup(pInt);

    pInt->mem = &linuxMem;


    pInt->private = (void *)calloc(1, sizeof(linuxInt10Priv));
    ((linuxInt10Priv*)pInt->private)->screen = pInt->scrnIndex;
    ((linuxInt10Priv*)pInt->private)->alloc =
    (void *)calloc(1, ALLOC_ENTRIES(getpagesize()));

    if (!pci_device_is_boot_vga(pInt->dev)) {
    fprintf(stderr, "Mapping high memory area\n");
    if ((high_mem = shmget(counter++, HIGH_MEM_SIZE,
                   IPC_CREAT | SHM_R | SHM_W)) == -1) {
        if (errno == ENOSYS)
        fprintf(stderr, "shmget error\n Please reconfigure"
               " your kernel to include System V IPC support\n");
        else
        fprintf(stderr, "shmget(highmem) error: %s\n",strerror(errno));
        goto error1;
    }
    } else {
    fprintf(stderr, "Mapping Video BIOS\n");
    videoBiosMapped = 1;
    if ((fd = open(DEV_MEM, O_RDWR, 0)) >= 0) {
        if ((vMem = mmap((void *)(V_BIOS), SYS_BIOS - V_BIOS,
                 PROT_READ | PROT_WRITE | PROT_EXEC,
                 MAP_SHARED | MAP_FIXED, fd, V_BIOS))
        == MAP_FAILED) {
        fprintf(stderr, "Cannot map V_BIOS\n");
        close(fd);
        goto error1;
        }
        close (fd);
    } else
        goto error1;
    }
    ((linuxInt10Priv*)pInt->private)->highMem = high_mem;

    fprintf(stderr, "Mapping 640kB area\n");
    if ((low_mem = shmget(counter++, V_RAM,
              IPC_CREAT | SHM_R | SHM_W)) == -1) {
    fprintf(stderr, "shmget(lowmem) error: %s\n",strerror(errno));
    goto error2;
    }

    ((linuxInt10Priv*)pInt->private)->lowMem = low_mem;
    base = shmat(low_mem, 0, 0);
    if (base == SHMERRORPTR) {
    fprintf(stderr, "shmat(low_mem) error: %s\n",strerror(errno));
    goto error3;
    }
    ((linuxInt10Priv *)pInt->private)->base = base;
    if (high_mem > -1) {
    base_high = shmat(high_mem, 0, 0);
    if (base_high == SHMERRORPTR) {
        fprintf(stderr, "shmat(high_mem) error: %s\n",strerror(errno));
        goto error3;
    }
    ((linuxInt10Priv*)pInt->private)->base_high = base_high;
    } else
    ((linuxInt10Priv*)pInt->private)->base_high = NULL;

    if (!MapCurrentInt10(pInt))
    goto error3;

    Int10Current = pInt;

    return;

error3:
    if (base_high)
    shmdt(base_high);
    shmdt(base);
    shmdt(0);
    if (base_high)
    shmdt((char*)HIGH_MEM);
    shmctl(low_mem, IPC_RMID, NULL);
    Int10Current = NULL;
error2:
    if (high_mem > -1)
    shmctl(high_mem, IPC_RMID,NULL);
error1:
    if (vMem)
    munmap(vMem, SYS_BIOS - V_BIOS);
    free(((linuxInt10Priv*)pInt->private)->alloc);
    free(pInt->private);
error:
    free(pInt);
    return;

#if 0
	void *m;

	if (context.ready)
		return;

	if (!LRMI_common_init())
		return;

	/*
	 Allocate a stack
	*/
	m = LRMI_alloc_real(DEFAULT_STACK_SIZE);

	context.stack_seg = (unsigned int)m >> 4;
	context.stack_off = DEFAULT_STACK_SIZE;

	/*
	 Allocate the return to 32 bit routine
	*/
	m = LRMI_alloc_real(2);

	context.ret_seg = (unsigned int)m >> 4;
	context.ret_off = (unsigned int)m & 0xf;

	((unsigned char *)m)[0] = 0xcd; 	/* int opcode */
	((unsigned char *)m)[1] = RETURN_TO_32_INT;

	memset(&context.vm, 0, sizeof(context.vm));

	/*
	 Enable kernel emulation of all ints except RETURN_TO_32_INT
	*/
#if defined(__linux__)
	memset(&context.vm.int_revectored, 0, sizeof(context.vm.int_revectored));
	set_bit(RETURN_TO_32_INT, &context.vm.int_revectored);
#elif defined(__NetBSD__) || defined(__OpenBSD__)
	set_bit(RETURN_TO_32_INT, &context.vm.int_byuser);
#elif defined(__FreeBSD__)
	set_bit(RETURN_TO_32_INT, &context.vm.init.int_map);
#endif

	context.ready = 1;
#endif
	return;
}

#if 0
static void
set_regs(struct LRMI_regs *r)
{
	CONTEXT_REGS.REG(edi) = r->edi;
	CONTEXT_REGS.REG(esi) = r->esi;
	CONTEXT_REGS.REG(ebp) = r->ebp;
	CONTEXT_REGS.REG(ebx) = r->ebx;
	CONTEXT_REGS.REG(edx) = r->edx;
	CONTEXT_REGS.REG(ecx) = r->ecx;
	CONTEXT_REGS.REG(eax) = r->eax;
	CONTEXT_REGS.REG(eflags) = DEFAULT_VM86_FLAGS;
	CONTEXT_REGS.REG(es) = r->es;
	CONTEXT_REGS.REG(ds) = r->ds;
	CONTEXT_REGS.REG(fs) = r->fs;
	CONTEXT_REGS.REG(gs) = r->gs;
}


static void
get_regs(struct LRMI_regs *r)
{
	r->edi = CONTEXT_REGS.REG(edi);
	r->esi = CONTEXT_REGS.REG(esi);
	r->ebp = CONTEXT_REGS.REG(ebp);
	r->ebx = CONTEXT_REGS.REG(ebx);
	r->edx = CONTEXT_REGS.REG(edx);
	r->ecx = CONTEXT_REGS.REG(ecx);
	r->eax = CONTEXT_REGS.REG(eax);
	r->flags = CONTEXT_REGS.REG(eflags);
	r->es = CONTEXT_REGS.REG(es);
	r->ds = CONTEXT_REGS.REG(ds);
	r->fs = CONTEXT_REGS.REG(fs);
	r->gs = CONTEXT_REGS.REG(gs);
}
#endif

#if 0
int
LRMI_call(struct LRMI_regs *r)
{
	unsigned int vret;

	memset(&CONTEXT_REGS, 0, sizeof(CONTEXT_REGS));

	set_regs(r);

	CONTEXT_REGS.REG(cs) = r->cs;
	CONTEXT_REGS.REG(eip) = r->ip;

	if (r->ss == 0 && r->sp == 0) {
		CONTEXT_REGS.REG(ss) = context.stack_seg;
		CONTEXT_REGS.REG(esp) = context.stack_off;
	} else {
		CONTEXT_REGS.REG(ss) = r->ss;
		CONTEXT_REGS.REG(esp) = r->sp;
	}

	pushw(context.ret_seg);
	pushw(context.ret_off);

	vret = run_vm86();

	get_regs(r);

	return vret;
}
#endif

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

    pre_int(pInt);

    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);
    }

    while(do_vm86(pInt)) {};

    pos_int(pInt);

#if  0
int
LRMI_int(int i, struct LRMI_regs *r)
{
	unsigned int vret;
	unsigned int seg, off;

	seg = get_int_seg(i);
	off = get_int_off(i);

	/*
	 If the interrupt is in regular memory, it's probably
	 still pointing at a dos TSR (which is now gone).
	*/
	if (seg < 0xa000 || (seg << 4) + off >= 0x100000) {
#ifdef LRMI_DEBUG
		fprintf(stderr, "Int 0x%x is not in rom (%04x:%04x)\n", i, seg, off);
#endif
		return 0;
	}

	memset(&CONTEXT_REGS, 0, sizeof(CONTEXT_REGS));

	set_regs(r);

	CONTEXT_REGS.REG(cs) = seg;
	CONTEXT_REGS.REG(eip) = off;

	if (r->ss == 0 && r->sp == 0) {
		CONTEXT_REGS.REG(ss) = context.stack_seg;
		CONTEXT_REGS.REG(esp) = context.stack_off;
	} else {
		CONTEXT_REGS.REG(ss) = r->ss;
		CONTEXT_REGS.REG(esp) = r->sp;
	}

	pushw(DEFAULT_VM86_FLAGS);
	pushw(context.ret_seg);
	pushw(context.ret_off);

	vret = run_vm86();

	get_regs(r);

	return vret;
#endif
}

void *
LRMI_alloc_real(xf86Int10InfoPtr pInt, int num, int *off)
{
    int pagesize = getpagesize();
    int num_pages = ALLOC_ENTRIES(pagesize);
    int i, j;

    for (i = 0; i < (num_pages - num); i++) {
    if (((linuxInt10Priv*)pInt->private)->alloc[i] == 0) {
        for (j = i; j < (num + i); j++)
        if ((((linuxInt10Priv*)pInt->private)->alloc[j] != 0))
            break;
        if (j == (num + i))
        break;
        else
        i = i + num;
    }
    }
    if (i == (num_pages - num))
    return NULL;

    for (j = i; j < (i + num); j++)
    ((linuxInt10Priv*)pInt->private)->alloc[j] = 1;

    *off = (i + 1) * pagesize;

    return ((linuxInt10Priv*)pInt->private)->base + ((i + 1) * pagesize);
}

void
LRMI_free_real(xf86Int10InfoPtr pInt, void *pbase, int num)
{
    int pagesize = getpagesize();
    int first = (((unsigned long)pbase
         - (unsigned long)((linuxInt10Priv*)pInt->private)->base)
    / pagesize) - 1;
    int i;

    for (i = first; i < (first + num); i++)
    ((linuxInt10Priv*)pInt->private)->alloc[i] = 0;
}

void *
LRMI_base_addr(xf86Int10InfoPtr pInt, unsigned long addr)
{
    if (addr < V_RAM)
    return ((linuxInt10Priv*)pInt->private)->base + addr;
    else if (addr < V_BIOS)
    return (void *)addr;
    else if (addr < SYS_BIOS) {
    if (((linuxInt10Priv*)pInt->private)->base_high)
        return (((linuxInt10Priv*)pInt->private)->base_high
                 - V_BIOS + addr);
    else
        return (void *)addr;
    } else
    return (void *)addr;
}

#else /* (__linux__ || __NetBSD__ || __FreeBSD__ || __OpenBSD__) && __i386__ */
#error "VM86 is not supported on your system!"
#endif