The Quake sources as originally release under the GPL license on December 21, 1999

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 *) &regs);
+    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;
+}
+