3 * Module: All Modules
\r
4 * Author(s): Chris Somers
\r
5 * Date: December 1, 1992
\r
8 minor mods by Alex Russell to simplify
\r
10 Must use memory model with FAR code
\r
12 Open Watcom patch by sparky4~
18 #if !defined(__LARGE__) && !defined(__COMPACT__) && !defined(__HUGE__)
\r
19 #error Invalid memory model for compiling MEMORY.C
\r
28 //static globals --------------------------------
\r
30 static int ActiveEMList[MAXEMHANDLES];
\r
31 static unsigned int EMMSeg;
\r
33 //forward declarations ---------------------------------
\r
35 static int EMPresent(void);
\r
36 static int EMReady(void);
\r
37 static unsigned int GetEMMSeg(void);
\r
38 static int GetEMHandle(int NumPages);
\r
39 static int EMMap(int Handle, int LogPg, int PhyPg);
\r
40 static int FreeEMHandle(int Handle);
\r
41 static int GetNumPages(int Handle);
\r
42 static int EMStateSave(int Handle);
\r
43 static void EMStateRestore(int Handle);
\r
45 /********************************************************************/
60 /********************************************************************/
\r
64 if (!EMPresent() || !EMReady()) return(NOTREADY);
\r
65 if (!(EMMSeg = GetEMMSeg())) return(NOTREADY); /*lint !e720 */
\r
67 } /* End of OpenEMM() */
\r
69 /********************************************************************/
\r
76 if (!EMMSeg) return;
\r
77 for (i = 0; i < MAXEMHANDLES; i++) {
\r
78 if (ActiveEMList[i]) {
\r
79 FreeEMHandle(ActiveEMList[i]);
\r
80 ActiveEMList[i] = 0;
\r
84 } /* End of CloseEMM() */
\r
86 /********************************************************************/
\r
91 return((EMMSeg) ? TRUE : FALSE); /* successfully opened? */
\r
92 } /* End of EMMInstalled() */
\r
94 /********************************************************************/
\r
100 unsigned long RtnVal = 0UL;
101 unsigned short interr=0;
\r
104 mov ah,0x42 /* get EMM free page count */
\r
107 js InternalError /* returns 80, 81, or 84 hex on error */
\r
108 mov Pages,bx /* number of unallocated 16K pages */
115 RtnVal = ((unsigned long)Pages << 14); /* Pages * 16K rtns bytes*/
\r
118 } /* End of EMMCoreLeft() */
\r
120 /********************************************************************/
\r
123 EMMalloc(int *Handle, int Pages)
\r
126 char *RtnPtr = NULL;
\r
129 *Handle = NOTREADY;
\r
132 if ((Pages < 1) || (Pages > 1020)) {
\r
133 *Handle = VALUE_OUTF_RANGE;
\r
136 for (i = 0; (i < MAXEMHANDLES) && (ActiveEMList[i]); i++) ;
\r
137 if (i == MAXEMHANDLES) {
\r
138 *Handle = NOFREEITEMS;
\r
141 if ((ActiveEMList[i] = GetEMHandle(Pages)) > 0) {
\r
142 RtnPtr = MK_FP(EMMSeg, 0);
\r
144 *Handle = ActiveEMList[i];
\r
145 return((void far *)RtnPtr);
\r
146 } /* End of EMMalloc() */
\r
148 /********************************************************************/
\r
151 EMMRealloc(int Handle, int Pages)
\r
153 int RtnCode = FALSE;
\r
155 if (!EMMSeg || (Pages < 0) || (Pages > 1020)) {
\r
159 mov ah,0x51 /* change # of pages */
\r
164 js NoGo /* returns 80 to 88 hex on error */
171 } /* End of EMMRealloc() */
\r
173 /********************************************************************/
\r
176 EMMFree(int Handle)
\r
180 if (!EMMSeg) return;
\r
181 for (i = 0; (i < MAXEMHANDLES) && (ActiveEMList[i] != Handle); i++) ;
\r
182 if (i >= MAXEMHANDLES) return;
\r
185 if (FreeEMHandle(ActiveEMList[i])) break;
\r
187 ActiveEMList[i] = 0;
\r
188 } /* End of EMMFree() */
\r
190 /********************************************************************/
\r
192 int /* EMM map for application */
\r
193 MapEMM(int Handle, int Start, int Pages)
\r
197 if (!EMMSeg) return(NOTREADY);
\r
198 for (i = 0; (i < MAXEMHANDLES) && (ActiveEMList[i] != Handle); i++) ;
\r
199 if (i == MAXEMHANDLES) return (NO_DATA);
\r
200 if ((GetNumPages(Handle) < Pages) || (Pages < 1) || (Pages > 4)) {
\r
201 return (VALUE_OUTF_RANGE);
\r
203 for (i = Start; i < Start + Pages; i++) {
\r
204 if (!EMMap(Handle, i, i - Start)) return(NO_DATA);
\r
207 } /* End of MapEMM() */
\r
209 /********************************************************************/
\r
211 void /* EMM unmap for application */
\r
212 UnmapEMM(int Handle, int Start, int Pages)
\r
216 if (!EMMSeg) return;
\r
217 for (i = 0; (i < MAXEMHANDLES) && (ActiveEMList[i] != Handle); i++) ;
\r
218 if (i == MAXEMHANDLES) return;
\r
220 if ((Pages < 1) || (j > 4)) return;
\r
222 for (i = Start; i < j; i++) {
\r
223 EMMap(Handle, NONE, i);
\r
225 } /* End of UnmapEMM() */
\r
227 /********************************************************************/
\r
229 int /* EMM map for devices - saves EMM state */
\r
230 UseEMM(int Handle, int Start, int Pages)
\r
232 EMStateSave(Handle);
\r
233 return(MapEMM(Handle, Start, Pages));
\r
234 } /* End of UseEMM() */
\r
236 /********************************************************************/
\r
238 void /* EMM unmap for devices - restores EMM state */
\r
239 SaveEMM(int Handle, int Start, int Pages)
\r
241 UnmapEMM(Handle, Start, Pages);
\r
242 EMStateRestore(Handle);
\r
243 } /* End of SaveEMM() */
\r
245 /********************************************************************/
\r
251 char EMName[] = "EMMXXXX0";
\r
254 _asm { /* can be replaced with getvect() */
\r
256 mov ax,0x3567 /* get vector for int 67h */
\r
262 t = MK_FP(Segment, 0x0A); /* point to driver name */
\r
264 for (i = 0; (i < 8) && (*s++ == *t++); i++) ; /* strncmp equivalent */
\r
266 if (i == 8) return(TRUE);
\r
268 } /*End of EMPresent() */
\r
270 /********************************************************************/
\r
277 mov ah,0x40 /* get EM Manager Status */
\r
280 jns Ready /* returns 80, 81, or 84 hex on error */
291 } /* End of EMReady() */
\r
293 /********************************************************************/
\r
295 static unsigned int
\r
298 unsigned int EMSegment;
\r
301 mov ah,0x41 /* get EMM page frame segment */
\r
304 js NotReady /* returns 80, 81, or 84 hex on error */
\r
308 mov EMSegment,NOTREADY
311 return(EMSegment); /*lint !e530 */
\r
314 // return(NOTREADY);
\r
315 } /* End of GetEMMSeg() */
\r
317 /********************************************************************/
\r
320 GetEMHandle(int NumPages)
\r
325 mov ah,0x43 /* get handle and allocate EM */
\r
326 mov bx,NumPages /* number of 16K pages to allocate */
\r
328 or ah,ah /* returns 80 to 89 hex on error */
\r
330 mov NewHandle,dx /* retrieve handle */
333 mov NewHandle,NO_DATA
339 // return(NO_DATA);
\r
340 } /* End of GetEMHandle() */
\r
342 /********************************************************************/
\r
345 EMMap(int Handle, int LogPg, int PhyPg)
\r
347 int RtnCode = NO_DATA;
\r
350 mov ax,PhyPg /* physical page: 0 - 3 in AL only */
\r
351 mov ah,0x44 /* map logical to physical page */
\r
352 mov bx,LogPg /* logical page: 0 - 1020 */
\r
355 or ah,ah /* returns 80 to 8B hex on error */
\r
362 // RtnCode = SUCCESS;
\r
366 } /* End of EMMap() */
\r
368 /********************************************************************/
\r
371 FreeEMHandle(int Handle)
\r
375 mov ah,0x45 /* free handle and deallocate EM */
\r
378 or ah,ah /* returns 80 to 86 hex on error */
\r
380 mov FreeEMShandle,SUCCESS
382 NotFreed: /* must retry if unsuccessful */
383 mov FreeEMShandle,NO_DATA
386 return(FreeEMShandle);
\r
388 //NotFreed: /* must retry if unsuccessful */
\r
389 // return(NO_DATA);
\r
390 } /* End of FreeEMHandle() */
\r
392 /********************************************************************/
\r
395 GetNumPages(int Handle)
\r
400 mov ah,0x4C /* get allocated pages for Handle */
\r
403 or ah,ah /* returns 80 to 84 hex on error */
\r
413 } /* End of GetNumPages() */
\r
415 /********************************************************************/
\r
418 EMStateSave(int Handle)
\r
420 int RtnCode = NO_MEMORY;
\r
422 mov ah,0x47 /* save page map under Handle */
\r
426 js Unsaved /* out of save space error */
430 // RtnCode = SUCCESS;
\r
434 } /* End of EMStateSave() */
\r
436 /********************************************************************/
\r
439 EMStateRestore(int Handle)
\r
442 mov ah,0x48 /* restore page map for Handle */
\r
444 int 0x67 /* ignore error */
\r
446 } /* End of EMStateRestore() */
\r