diff options
Diffstat (limited to 'WinQuake/dos_v2.c')
| -rw-r--r-- | WinQuake/dos_v2.c | 257 |
1 files changed, 257 insertions, 0 deletions
diff --git a/WinQuake/dos_v2.c b/WinQuake/dos_v2.c new file mode 100644 index 0000000..3adf2cb --- /dev/null +++ b/WinQuake/dos_v2.c @@ -0,0 +1,257 @@ +/* +Copyright (C) 1996-1997 Id Software, Inc. + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +*/ +#include <sys/segments.h> +#include <go32.h> +#include <unistd.h> +#include <sys/nearptr.h> +#include <dos.h> +#include <string.h> +#include <dpmi.h> +// #include <osfcn.h> +#include <bios.h> + +#include "dosisms.h" + +_go32_dpmi_registers hmm; + +// globals +regs_t regs; +void (*dos_error_func)(char *msg, ...); + +static unsigned conventional_memory = -1; + +__dpmi_regs callback_regs; + +void map_in_conventional_memory(void) +{ + if (conventional_memory == -1) + { + if (__djgpp_nearptr_enable()) + { + conventional_memory = __djgpp_conventional_base; + } + } +} + +unsigned int ptr2real(void *ptr) +{ + map_in_conventional_memory(); + return (int)ptr - conventional_memory; +} + +void *real2ptr(unsigned int real) +{ + map_in_conventional_memory(); + return (void *) (real + conventional_memory); +} + +void *far2ptr(unsigned int farptr) +{ + return real2ptr(((farptr & ~0xffff) >>12) + (farptr&0xffff)); +} + +unsigned int ptr2far(void *ptr) +{ + return ((ptr2real(ptr)&~0xf) << 12) + (ptr2real(ptr) & 0xf); +} + +int dos_inportb(int port) +{ + return inportb(port); +} + +int dos_inportw(int port) +{ + return inportw(port); +} + +void dos_outportb(int port, int val) +{ + outportb(port, val); +} + +void dos_outportw(int port, int val) +{ + outportw(port, val); +} + +void dos_irqenable(void) +{ + enable(); +} + +void dos_irqdisable(void) +{ + disable(); +} + +// +// Returns 0 on success +// + +int dos_int86(int vec) +{ + int rc; + regs.x.ss = regs.x.sp = 0; + rc = _go32_dpmi_simulate_int(vec, (_go32_dpmi_registers *) ®s); + return rc || (regs.x.flags & 1); +} + +int dos_int386(int vec, regs_t *inregs, regs_t *outregs) +{ + int rc; + memcpy(outregs, inregs, sizeof(regs_t)); + outregs->x.ss = outregs->x.sp = 0; + rc = _go32_dpmi_simulate_int(vec, (_go32_dpmi_registers *) outregs); + return rc || (outregs->x.flags & 1); +} + +// +// Because of a quirk in dj's alloc-dos-memory wrapper, you need to keep +// the seginfo structure around for when you free the mem. +// + +static _go32_dpmi_seginfo seginfo[10]; + +void *dos_getmemory(int size) +{ + + int rc; + _go32_dpmi_seginfo info; + static int firsttime=1; + int i; + + if (firsttime) + { + memset(seginfo, 0, sizeof(seginfo)); + firsttime = 0; + } + + info.size = (size+15) / 16; + rc = _go32_dpmi_allocate_dos_memory(&info); + if (rc) + return 0; + + for (i=0;i<10;i++) + if (!seginfo[i].rm_segment) break; + seginfo[i] = info; + return real2ptr((int) info.rm_segment << 4); + +} + +void dos_freememory(void *ptr) +{ + + int i; + int segment; + + segment = ptr2real(ptr) >> 4; + for (i=0 ; i<10 ; i++) + if (seginfo[i].rm_segment == segment) + { + _go32_dpmi_free_dos_memory(&seginfo[i]); + seginfo[i].rm_segment = 0; + break; + } + +} + +static struct handlerhistory_s +{ + int intr; + _go32_dpmi_seginfo pm_oldvec; +} handlerhistory[4]; + +static int handlercount=0; + +void dos_registerintr(int intr, void (*handler)(void)) +{ + _go32_dpmi_seginfo info; + struct handlerhistory_s *oldstuff; + + oldstuff = &handlerhistory[handlercount]; + +// remember old handler + _go32_dpmi_get_protected_mode_interrupt_vector(intr, &oldstuff->pm_oldvec); + oldstuff->intr = intr; + + info.pm_offset = (int) handler; + _go32_dpmi_allocate_iret_wrapper(&info); + +// set new protected mode handler + _go32_dpmi_set_protected_mode_interrupt_vector(intr, &info); + + handlercount++; + +} + +void dos_restoreintr(int intr) +{ + + int i; + struct handlerhistory_s *oldstuff; + +// find and reinstall previous interrupt + for (i=0 ; i<handlercount ; i++) + { + oldstuff = &handlerhistory[i]; + if (oldstuff->intr == intr) + { + _go32_dpmi_set_protected_mode_interrupt_vector(intr, + &oldstuff->pm_oldvec); + oldstuff->intr = -1; + break; + } + } + +} + +void dos_usleep(int usecs) +{ + usleep(usecs); +} + +int dos_getheapsize(void) +{ + return _go32_dpmi_remaining_physical_memory(); +} + +int dos_lockmem(void *addr, int size) +{ + __dpmi_meminfo info; + info.address = (long) addr + __djgpp_base_address; + info.size = size; + if (__dpmi_lock_linear_region(&info)) + return __dpmi_error; + else + return 0; +} + +int dos_unlockmem(void *addr, int size) +{ + __dpmi_meminfo info; + info.address = (long) addr + __djgpp_base_address; + info.size = size; + if (__dpmi_unlock_linear_region(&info)) + return __dpmi_error; + else + return 0; +} + |