/* | |
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; | |
} | |