![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dos_v2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quake1|
Return to dos_v2.c CVS log | Up to [Quake] / quake1 |
1.1 root 1: #include <sys/segments.h>
2: #include <go32.h>
3: #include <unistd.h>
4: #include <sys/nearptr.h>
5: #include <dos.h>
6: #include <string.h>
7: #include <dpmi.h>
8: // #include <osfcn.h>
9: #include <bios.h>
10:
11: #include "dosisms.h"
12:
13: _go32_dpmi_registers hmm;
14:
15: // globals
16: regs_t regs;
17: void (*dos_error_func)(char *msg, ...);
18:
19: static unsigned conventional_memory = -1;
20:
21: __dpmi_regs callback_regs;
22:
23: void map_in_conventional_memory(void)
24: {
25: if (conventional_memory == -1)
26: {
27: if (__djgpp_nearptr_enable())
28: {
29: conventional_memory = __djgpp_conventional_base;
30: }
31: }
32: }
33:
34: unsigned int ptr2real(void *ptr)
35: {
36: map_in_conventional_memory();
37: return (int)ptr - conventional_memory;
38: }
39:
40: void *real2ptr(unsigned int real)
41: {
42: map_in_conventional_memory();
43: return (void *) (real + conventional_memory);
44: }
45:
46: void *far2ptr(unsigned int farptr)
47: {
48: return real2ptr(((farptr & ~0xffff) >>12) + (farptr&0xffff));
49: }
50:
51: unsigned int ptr2far(void *ptr)
52: {
53: return ((ptr2real(ptr)&~0xf) << 12) + (ptr2real(ptr) & 0xf);
54: }
55:
56: int dos_inportb(int port)
57: {
58: return inportb(port);
59: }
60:
61: int dos_inportw(int port)
62: {
63: return inportw(port);
64: }
65:
66: void dos_outportb(int port, int val)
67: {
68: outportb(port, val);
69: }
70:
71: void dos_outportw(int port, int val)
72: {
73: outportw(port, val);
74: }
75:
76: void dos_irqenable(void)
77: {
78: enable();
79: }
80:
81: void dos_irqdisable(void)
82: {
83: disable();
84: }
85:
86: //
87: // Returns 0 on success
88: //
89:
90: int dos_int86(int vec)
91: {
92: int rc;
93: regs.x.ss = regs.x.sp = 0;
94: rc = _go32_dpmi_simulate_int(vec, (_go32_dpmi_registers *) ®s);
95: return rc || (regs.x.flags & 1);
96: }
97:
98: int dos_int386(int vec, regs_t *inregs, regs_t *outregs)
99: {
100: int rc;
101: memcpy(outregs, inregs, sizeof(regs_t));
102: outregs->x.ss = outregs->x.sp = 0;
103: rc = _go32_dpmi_simulate_int(vec, (_go32_dpmi_registers *) outregs);
104: return rc || (outregs->x.flags & 1);
105: }
106:
107: //
108: // Because of a quirk in dj's alloc-dos-memory wrapper, you need to keep
109: // the seginfo structure around for when you free the mem.
110: //
111:
112: static _go32_dpmi_seginfo seginfo[10];
113:
114: void *dos_getmemory(int size)
115: {
116:
117: int rc;
118: _go32_dpmi_seginfo info;
119: static int firsttime=1;
120: int i;
121:
122: if (firsttime)
123: {
124: memset(seginfo, 0, sizeof(seginfo));
125: firsttime = 0;
126: }
127:
128: info.size = (size+15) / 16;
129: rc = _go32_dpmi_allocate_dos_memory(&info);
130: if (rc)
131: return 0;
132:
133: for (i=0;i<10;i++)
134: if (!seginfo[i].rm_segment) break;
135: seginfo[i] = info;
136: return real2ptr((int) info.rm_segment << 4);
137:
138: }
139:
140: void dos_freememory(void *ptr)
141: {
142:
143: int i;
144: int segment;
145:
146: segment = ptr2real(ptr) >> 4;
147: for (i=0 ; i<10 ; i++)
148: if (seginfo[i].rm_segment == segment)
149: {
150: _go32_dpmi_free_dos_memory(&seginfo[i]);
151: seginfo[i].rm_segment = 0;
152: break;
153: }
154:
155: }
156:
157: static struct handlerhistory_s
158: {
159: int intr;
160: _go32_dpmi_seginfo pm_oldvec;
161: } handlerhistory[4];
162:
163: static int handlercount=0;
164:
165: void dos_registerintr(int intr, void (*handler)(void))
166: {
167: _go32_dpmi_seginfo info;
168: struct handlerhistory_s *oldstuff;
169:
170: oldstuff = &handlerhistory[handlercount];
171:
172: // remember old handler
173: _go32_dpmi_get_protected_mode_interrupt_vector(intr, &oldstuff->pm_oldvec);
174: oldstuff->intr = intr;
175:
176: info.pm_offset = (int) handler;
177: _go32_dpmi_allocate_iret_wrapper(&info);
178:
179: // set new protected mode handler
180: _go32_dpmi_set_protected_mode_interrupt_vector(intr, &info);
181:
182: handlercount++;
183:
184: }
185:
186: void dos_restoreintr(int intr)
187: {
188:
189: int i;
190: struct handlerhistory_s *oldstuff;
191:
192: // find and reinstall previous interrupt
193: for (i=0 ; i<handlercount ; i++)
194: {
195: oldstuff = &handlerhistory[i];
196: if (oldstuff->intr == intr)
197: {
198: _go32_dpmi_set_protected_mode_interrupt_vector(intr,
199: &oldstuff->pm_oldvec);
200: oldstuff->intr = -1;
201: break;
202: }
203: }
204:
205: }
206:
207: void dos_usleep(int usecs)
208: {
209: usleep(usecs);
210: }
211:
212: int dos_getheapsize(void)
213: {
214: return _go32_dpmi_remaining_physical_memory();
215: }
216:
217: int dos_lockmem(void *addr, int size)
218: {
219: __dpmi_meminfo info;
220: info.address = (long) addr + __djgpp_base_address;
221: info.size = size;
222: if (__dpmi_lock_linear_region(&info))
223: return __dpmi_error;
224: else
225: return 0;
226: }
227:
228: int dos_unlockmem(void *addr, int size)
229: {
230: __dpmi_meminfo info;
231: info.address = (long) addr + __djgpp_base_address;
232: info.size = size;
233: if (__dpmi_unlock_linear_region(&info))
234: return __dpmi_error;
235: else
236: return 0;
237: }
238:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.