Git conversion: Make reactos the root directory, move rosapps, rostests, wallpapers...
[reactos.git] / subsystems / mvdm / ntvdm / dos / dos32krnl / himem.c
1 /*
2 * COPYRIGHT: GPLv2+ - See COPYING in the top level directory
3 * PROJECT: ReactOS Virtual DOS Machine
4 * FILE: subsystems/mvdm/ntvdm/dos/dos32krnl/himem.c
5 * PURPOSE: DOS XMS Driver and UMB Provider
6 * PROGRAMMERS: Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
7 * Hermes Belusca-Maito (hermes.belusca@sfr.fr)
8 *
9 * DOCUMENTATION: Official specifications:
10 * XMS v2.0: http://www.phatcode.net/res/219/files/xms20.txt
11 * XMS v3.0: http://www.phatcode.net/res/219/files/xms30.txt
12 *
13 * About the implementation of UMBs in DOS:
14 * ----------------------------------------
15 * DOS needs a UMB provider to be able to use chunks of RAM in the C000-EFF0
16 * memory region. A UMB provider detects regions of memory that do not contain
17 * any ROMs or other system mapped area such as video RAM.
18 *
19 * Where can UMB providers be found?
20 *
21 * The XMS specification (see himem.c) provides three APIs to create, free, and
22 * resize UMB blocks. As such, DOS performs calls into the XMS driver chain to
23 * request UMB blocks and include them into the DOS memory arena.
24 * However, is it only the HIMEM driver (implementing the XMS specification)
25 * which can provide UMBs? It appears that this is not necessarily the case:
26 * for example the MS HIMEM versions do not implement the UMB APIs; instead
27 * it is the EMS driver (EMM386) which provides them, by hooking into the XMS
28 * driver chain (see https://support.microsoft.com/en-us/kb/95555 : "MS-DOS 5.0
29 * and later EMM386.EXE can also be configured to provide UMBs according to the
30 * XMS. This causes EMM386.EXE to be a provider of the UMB portion of the XMS.").
31 *
32 * Some alternative replacements of HIMEM/EMM386 (for example in FreeDOS)
33 * implement everything inside only one driver (XMS+EMS+UMB provider).
34 * Finally there are some UMB providers that exist separately of XMS and EMS
35 * drivers (for example, UMBPCI): they use hardware-specific tricks to discover
36 * and provide UMBs.
37 *
38 * For more details, see:
39 * http://www.freedos.org/technotes/technote/txt/169.txt
40 * http://www.freedos.org/technotes/technote/txt/202.txt
41 * http://www.uncreativelabs.net/textfiles/system/UMB.TXT
42 *
43 * This DOS XMS Driver provides the UMB APIs that are implemented on top
44 * of the internal Upper Memory Area Manager, in umamgr.c
45 */
46
47 /* INCLUDES *******************************************************************/
48
49 #include "ntvdm.h"
50
51 #define NDEBUG
52 #include <debug.h>
53
54 #include "emulator.h"
55 #include "cpu/bop.h"
56 #include "../../memory.h"
57 #include "bios/umamgr.h"
58
59 #include "device.h"
60 #include "himem.h"
61
62 #define XMS_DEVICE_NAME "XMSXXXX0"
63
64 /* BOP Identifiers */
65 #define BOP_XMS 0x52
66
67 /* PRIVATE VARIABLES **********************************************************/
68
69 static const BYTE EntryProcedure[] =
70 {
71 0xEB, // jmp short +0x03
72 0x03,
73 0x90, // nop
74 0x90, // nop
75 0x90, // nop
76 LOBYTE(EMULATOR_BOP),
77 HIBYTE(EMULATOR_BOP),
78 BOP_XMS,
79 0xCB // retf
80 };
81
82 static PDOS_DEVICE_NODE Node = NULL;
83 static XMS_HANDLE HandleTable[XMS_MAX_HANDLES];
84 static WORD FreeBlocks = XMS_BLOCKS;
85 static RTL_BITMAP AllocBitmap;
86 static ULONG BitmapBuffer[(XMS_BLOCKS + 31) / 32];
87
88 /*
89 * This value is associated to HIMEM's "/HMAMIN=" switch. It indicates the
90 * minimum account of space in the HMA a program can use, and is used in
91 * conjunction with the "Request HMA" function.
92 *
93 * NOTE: The "/HMAMIN=" value is in kilo-bytes, whereas HmaMinSize is in bytes.
94 *
95 * Default value: 0. This causes the HMA to be allocated on a first come,
96 * first served basis.
97 */
98 static WORD HmaMinSize = 0;
99 /*
100 * Flag used by "Request/Release HMA" functions, which indicates
101 * whether the HMA was reserved or not.
102 */
103 static BOOLEAN IsHmaReserved = FALSE;
104
105 /*
106 * Flag used by "Global Enable/Disable A20" functions, so that they don't
107 * need to re-change the state of A20 if it was already enabled/disabled.
108 */
109 static BOOLEAN IsA20Enabled = FALSE;
110 /*
111 * This flag is set to TRUE or FALSE when A20 line was already disabled or
112 * enabled when XMS driver was loaded.
113 * In case A20 was disabled, we are allowed to modify it. In case A20 was
114 * already enabled, we are not allowed to touch it.
115 */
116 static BOOLEAN CanChangeA20 = TRUE;
117 /*
118 * Count for enabling or disabling the A20 line. The A20 line is enabled
119 * only if the enabling count is greater than or equal to 0.
120 */
121 static LONG A20EnableCount = 0;
122
123 /* A20 LINE HELPERS ***********************************************************/
124
125 static VOID XmsLocalEnableA20(VOID)
126 {
127 /* Enable A20 only if we can do so, otherwise make the caller believe we enabled it */
128 if (!CanChangeA20) goto Quit;
129
130 /* The count is zero so enable A20 */
131 if (A20EnableCount == 0) EmulatorSetA20(TRUE);
132
133 ++A20EnableCount;
134
135 Quit:
136 setAX(0x0001); /* Line successfully enabled */
137 setBL(XMS_STATUS_SUCCESS);
138 return;
139 }
140
141 static VOID XmsLocalDisableA20(VOID)
142 {
143 UCHAR Result = XMS_STATUS_SUCCESS;
144
145 /* Disable A20 only if we can do so, otherwise make the caller believe we disabled it */
146 if (!CanChangeA20) goto Quit;
147
148 /* If the count is already zero, fail */
149 if (A20EnableCount == 0) goto Fail;
150
151 --A20EnableCount;
152
153 /* The count is zero so disable A20 */
154 if (A20EnableCount == 0)
155 EmulatorSetA20(FALSE); // Result = XMS_STATUS_SUCCESS;
156 else
157 Result = XMS_STATUS_A20_STILL_ENABLED;
158
159 Quit:
160 setAX(0x0001); /* Line successfully disabled */
161 setBL(Result);
162 return;
163
164 Fail:
165 setAX(0x0000); /* Line failed to be disabled */
166 setBL(XMS_STATUS_A20_ERROR);
167 return;
168 }
169
170 /* PRIVATE FUNCTIONS **********************************************************/
171
172 static inline PXMS_HANDLE GetHandleRecord(WORD Handle)
173 {
174 PXMS_HANDLE Entry;
175 if (Handle == 0 || Handle >= XMS_MAX_HANDLES) return NULL;
176
177 Entry = &HandleTable[Handle - 1];
178 return Entry->Size ? Entry : NULL;
179 }
180
181 static inline BOOLEAN ValidateHandle(PXMS_HANDLE HandleEntry)
182 {
183 return (HandleEntry != NULL && HandleEntry->Handle != 0);
184 }
185
186 static WORD XmsGetLargestFreeBlock(VOID)
187 {
188 WORD Result = 0;
189 DWORD CurrentIndex = 0;
190 ULONG RunStart;
191 ULONG RunSize;
192
193 while (CurrentIndex < XMS_BLOCKS)
194 {
195 RunSize = RtlFindNextForwardRunClear(&AllocBitmap, CurrentIndex, &RunStart);
196 if (RunSize == 0) break;
197
198 /* Update the maximum */
199 if (RunSize > Result) Result = RunSize;
200
201 /* Go to the next run */
202 CurrentIndex = RunStart + RunSize;
203 }
204
205 return Result;
206 }
207
208 static UCHAR XmsAlloc(WORD Size, PWORD Handle)
209 {
210 BYTE i;
211 PXMS_HANDLE HandleEntry;
212 DWORD CurrentIndex = 0;
213 ULONG RunStart;
214 ULONG RunSize;
215
216 if (Size > FreeBlocks) return XMS_STATUS_OUT_OF_MEMORY;
217
218 for (i = 0; i < XMS_MAX_HANDLES; i++)
219 {
220 HandleEntry = &HandleTable[i];
221 if (HandleEntry->Handle == 0)
222 {
223 *Handle = i + 1;
224 break;
225 }
226 }
227
228 if (i == XMS_MAX_HANDLES) return XMS_STATUS_OUT_OF_HANDLES;
229
230 /* Optimize blocks */
231 for (i = 0; i < XMS_MAX_HANDLES; i++)
232 {
233 /* Skip free and locked blocks */
234 if (HandleEntry->Handle == 0 || HandleEntry->LockCount > 0) continue;
235
236 CurrentIndex = (HandleEntry->Address - XMS_ADDRESS) / XMS_BLOCK_SIZE;
237
238 /* Check if there is any free space before this block */
239 RunSize = RtlFindLastBackwardRunClear(&AllocBitmap, CurrentIndex, &RunStart);
240 if (RunSize == 0) break;
241
242 /* Move this block back */
243 RtlMoveMemory((PVOID)REAL_TO_PHYS(HandleEntry->Address - RunSize * XMS_BLOCK_SIZE),
244 (PVOID)REAL_TO_PHYS(HandleEntry->Address),
245 RunSize * XMS_BLOCK_SIZE);
246
247 /* Update the address */
248 HandleEntry->Address -= RunSize * XMS_BLOCK_SIZE;
249 }
250
251 while (CurrentIndex < XMS_BLOCKS)
252 {
253 RunSize = RtlFindNextForwardRunClear(&AllocBitmap, CurrentIndex, &RunStart);
254 if (RunSize == 0) break;
255
256 if (RunSize >= HandleEntry->Size)
257 {
258 /* Allocate it here */
259 HandleEntry->Handle = i + 1;
260 HandleEntry->LockCount = 0;
261 HandleEntry->Size = Size;
262 HandleEntry->Address = XMS_ADDRESS + RunStart * XMS_BLOCK_SIZE;
263
264 FreeBlocks -= Size;
265 RtlSetBits(&AllocBitmap, RunStart, HandleEntry->Size);
266
267 return XMS_STATUS_SUCCESS;
268 }
269
270 /* Keep searching */
271 CurrentIndex = RunStart + RunSize;
272 }
273
274 return XMS_STATUS_OUT_OF_MEMORY;
275 }
276
277 static UCHAR XmsRealloc(WORD Handle, WORD NewSize)
278 {
279 DWORD BlockNumber;
280 PXMS_HANDLE HandleEntry = GetHandleRecord(Handle);
281 DWORD CurrentIndex = 0;
282 ULONG RunStart;
283 ULONG RunSize;
284
285 if (!ValidateHandle(HandleEntry))
286 return XMS_STATUS_INVALID_HANDLE;
287
288 if (HandleEntry->LockCount)
289 return XMS_STATUS_LOCKED;
290
291 /* Get the block number */
292 BlockNumber = (HandleEntry->Address - XMS_ADDRESS) / XMS_BLOCK_SIZE;
293
294 if (NewSize < HandleEntry->Size)
295 {
296 /* Just reduce the size of this block */
297 RtlClearBits(&AllocBitmap, BlockNumber + NewSize, HandleEntry->Size - NewSize);
298 FreeBlocks += HandleEntry->Size - NewSize;
299 HandleEntry->Size = NewSize;
300 }
301 else if (NewSize > HandleEntry->Size)
302 {
303 /* Check if we can expand in-place */
304 if (RtlAreBitsClear(&AllocBitmap,
305 BlockNumber + HandleEntry->Size,
306 NewSize - HandleEntry->Size))
307 {
308 /* Just increase the size of this block */
309 RtlSetBits(&AllocBitmap,
310 BlockNumber + HandleEntry->Size,
311 NewSize - HandleEntry->Size);
312 FreeBlocks -= NewSize - HandleEntry->Size;
313 HandleEntry->Size = NewSize;
314
315 /* We're done */
316 return XMS_STATUS_SUCCESS;
317 }
318
319 /* Deallocate the current block range */
320 RtlClearBits(&AllocBitmap, BlockNumber, HandleEntry->Size);
321
322 /* Find a new place for this block */
323 while (CurrentIndex < XMS_BLOCKS)
324 {
325 RunSize = RtlFindNextForwardRunClear(&AllocBitmap, CurrentIndex, &RunStart);
326 if (RunSize == 0) break;
327
328 if (RunSize >= NewSize)
329 {
330 /* Allocate the new range */
331 RtlSetBits(&AllocBitmap, RunStart, NewSize);
332
333 /* Move the data to the new location */
334 RtlMoveMemory((PVOID)REAL_TO_PHYS(XMS_ADDRESS + RunStart * XMS_BLOCK_SIZE),
335 (PVOID)REAL_TO_PHYS(HandleEntry->Address),
336 HandleEntry->Size * XMS_BLOCK_SIZE);
337
338 /* Update the handle entry */
339 HandleEntry->Address = XMS_ADDRESS + RunStart * XMS_BLOCK_SIZE;
340 HandleEntry->Size = NewSize;
341
342 /* Update the free block counter */
343 FreeBlocks -= NewSize - HandleEntry->Size;
344
345 return XMS_STATUS_SUCCESS;
346 }
347
348 /* Keep searching */
349 CurrentIndex = RunStart + RunSize;
350 }
351
352 /* Restore the old block range */
353 RtlSetBits(&AllocBitmap, BlockNumber, HandleEntry->Size);
354 return XMS_STATUS_OUT_OF_MEMORY;
355 }
356
357 return XMS_STATUS_SUCCESS;
358 }
359
360 static UCHAR XmsFree(WORD Handle)
361 {
362 DWORD BlockNumber;
363 PXMS_HANDLE HandleEntry = GetHandleRecord(Handle);
364
365 if (!ValidateHandle(HandleEntry))
366 return XMS_STATUS_INVALID_HANDLE;
367
368 if (HandleEntry->LockCount)
369 return XMS_STATUS_LOCKED;
370
371 BlockNumber = (HandleEntry->Address - XMS_ADDRESS) / XMS_BLOCK_SIZE;
372 RtlClearBits(&AllocBitmap, BlockNumber, HandleEntry->Size);
373
374 HandleEntry->Handle = 0;
375 FreeBlocks += HandleEntry->Size;
376
377 return XMS_STATUS_SUCCESS;
378 }
379
380 static UCHAR XmsLock(WORD Handle, PDWORD Address)
381 {
382 PXMS_HANDLE HandleEntry = GetHandleRecord(Handle);
383
384 if (!ValidateHandle(HandleEntry))
385 return XMS_STATUS_INVALID_HANDLE;
386
387 if (HandleEntry->LockCount == 0xFF)
388 return XMS_STATUS_LOCK_OVERFLOW;
389
390 /* Increment the lock count */
391 HandleEntry->LockCount++;
392 *Address = HandleEntry->Address;
393
394 return XMS_STATUS_SUCCESS;
395 }
396
397 static UCHAR XmsUnlock(WORD Handle)
398 {
399 PXMS_HANDLE HandleEntry = GetHandleRecord(Handle);
400
401 if (!ValidateHandle(HandleEntry))
402 return XMS_STATUS_INVALID_HANDLE;
403
404 if (!HandleEntry->LockCount)
405 return XMS_STATUS_NOT_LOCKED;
406
407 /* Decrement the lock count */
408 HandleEntry->LockCount--;
409
410 return XMS_STATUS_SUCCESS;
411 }
412
413 static VOID WINAPI XmsBopProcedure(LPWORD Stack)
414 {
415 switch (getAH())
416 {
417 /* Get XMS Version */
418 case 0x00:
419 {
420 setAX(0x0300); /* XMS version 3.00 */
421 setBX(0x0301); /* Driver version 3.01 */
422 setDX(0x0001); /* HMA present */
423 break;
424 }
425
426 /* Request HMA */
427 case 0x01:
428 {
429 /* Check whether HMA is already reserved */
430 if (IsHmaReserved)
431 {
432 /* It is, bail out */
433 setAX(0x0000);
434 setBL(XMS_STATUS_HMA_IN_USE);
435 break;
436 }
437
438 // NOTE: We implicitely suppose that we always have HMA.
439 // If not, we should fail there with the XMS_STATUS_HMA_DOES_NOT_EXIST
440 // error code.
441
442 /* Check whether the requested size is above the minimal allowed one */
443 if (getDX() < HmaMinSize)
444 {
445 /* It is not, bail out */
446 setAX(0x0000);
447 setBL(XMS_STATUS_HMA_MIN_SIZE);
448 break;
449 }
450
451 /* Reserve it */
452 IsHmaReserved = TRUE;
453 setAX(0x0001);
454 setBL(XMS_STATUS_SUCCESS);
455 break;
456 }
457
458 /* Release HMA */
459 case 0x02:
460 {
461 /* Check whether HMA was reserved */
462 if (!IsHmaReserved)
463 {
464 /* It was not, bail out */
465 setAX(0x0000);
466 setBL(XMS_STATUS_HMA_NOT_ALLOCATED);
467 break;
468 }
469
470 /* Release it */
471 IsHmaReserved = FALSE;
472 setAX(0x0001);
473 setBL(XMS_STATUS_SUCCESS);
474 break;
475 }
476
477 /* Global Enable A20 */
478 case 0x03:
479 {
480 /* Enable A20 if needed */
481 if (!IsA20Enabled)
482 {
483 XmsLocalEnableA20();
484 if (getAX() != 0x0001)
485 {
486 /* XmsLocalEnableA20 failed and already set AX and BL to their correct values */
487 break;
488 }
489
490 IsA20Enabled = TRUE;
491 }
492
493 setAX(0x0001); /* Line successfully enabled */
494 setBL(XMS_STATUS_SUCCESS);
495 break;
496 }
497
498 /* Global Disable A20 */
499 case 0x04:
500 {
501 UCHAR Result = XMS_STATUS_SUCCESS;
502
503 /* Disable A20 if needed */
504 if (IsA20Enabled)
505 {
506 XmsLocalDisableA20();
507 if (getAX() != 0x0001)
508 {
509 /* XmsLocalDisableA20 failed and already set AX and BL to their correct values */
510 break;
511 }
512
513 IsA20Enabled = FALSE;
514 Result = getBL();
515 }
516
517 setAX(0x0001); /* Line successfully disabled */
518 setBL(Result);
519 break;
520 }
521
522 /* Local Enable A20 */
523 case 0x05:
524 {
525 /* This call sets AX and BL to their correct values */
526 XmsLocalEnableA20();
527 break;
528 }
529
530 /* Local Disable A20 */
531 case 0x06:
532 {
533 /* This call sets AX and BL to their correct values */
534 XmsLocalDisableA20();
535 break;
536 }
537
538 /* Query A20 State */
539 case 0x07:
540 {
541 setAX(EmulatorGetA20());
542 setBL(XMS_STATUS_SUCCESS);
543 break;
544 }
545
546 /* Query Free Extended Memory */
547 case 0x08:
548 {
549 setAX(XmsGetLargestFreeBlock());
550 setDX(FreeBlocks);
551
552 if (FreeBlocks > 0)
553 setBL(XMS_STATUS_SUCCESS);
554 else
555 setBL(XMS_STATUS_OUT_OF_MEMORY);
556
557 break;
558 }
559
560 /* Allocate Extended Memory Block */
561 case 0x09:
562 {
563 WORD Handle;
564 UCHAR Result = XmsAlloc(getDX(), &Handle);
565
566 if (Result == XMS_STATUS_SUCCESS)
567 {
568 setAX(1);
569 setDX(Handle);
570 }
571 else
572 {
573 setAX(0);
574 setBL(Result);
575 }
576
577 break;
578 }
579
580 /* Free Extended Memory Block */
581 case 0x0A:
582 {
583 UCHAR Result = XmsFree(getDX());
584
585 setAX(Result == XMS_STATUS_SUCCESS);
586 setBL(Result);
587 break;
588 }
589
590 /* Move Extended Memory Block */
591 case 0x0B:
592 {
593 PVOID SourceAddress, DestAddress;
594 PXMS_COPY_DATA CopyData = (PXMS_COPY_DATA)SEG_OFF_TO_PTR(getDS(), getSI());
595 PXMS_HANDLE HandleEntry;
596
597 if (CopyData->SourceHandle)
598 {
599 HandleEntry = GetHandleRecord(CopyData->SourceHandle);
600 if (!ValidateHandle(HandleEntry))
601 {
602 setAX(0);
603 setBL(XMS_STATUS_BAD_SRC_HANDLE);
604 break;
605 }
606
607 if (CopyData->SourceOffset >= HandleEntry->Size * XMS_BLOCK_SIZE)
608 {
609 setAX(0);
610 setBL(XMS_STATUS_BAD_SRC_OFFSET);
611 }
612
613 SourceAddress = (PVOID)REAL_TO_PHYS(HandleEntry->Address + CopyData->SourceOffset);
614 }
615 else
616 {
617 /* The offset is actually a 16-bit segment:offset pointer */
618 SourceAddress = FAR_POINTER(CopyData->SourceOffset);
619 }
620
621 if (CopyData->DestHandle)
622 {
623 HandleEntry = GetHandleRecord(CopyData->DestHandle);
624 if (!ValidateHandle(HandleEntry))
625 {
626 setAX(0);
627 setBL(XMS_STATUS_BAD_DEST_HANDLE);
628 break;
629 }
630
631 if (CopyData->DestOffset >= HandleEntry->Size * XMS_BLOCK_SIZE)
632 {
633 setAX(0);
634 setBL(XMS_STATUS_BAD_DEST_OFFSET);
635 }
636
637 DestAddress = (PVOID)REAL_TO_PHYS(HandleEntry->Address + CopyData->DestOffset);
638 }
639 else
640 {
641 /* The offset is actually a 16-bit segment:offset pointer */
642 DestAddress = FAR_POINTER(CopyData->DestOffset);
643 }
644
645 /* Perform the move */
646 RtlMoveMemory(DestAddress, SourceAddress, CopyData->Count);
647
648 setAX(1);
649 setBL(XMS_STATUS_SUCCESS);
650 break;
651 }
652
653 /* Lock Extended Memory Block */
654 case 0x0C:
655 {
656 DWORD Address;
657 UCHAR Result = XmsLock(getDX(), &Address);
658
659 if (Result == XMS_STATUS_SUCCESS)
660 {
661 setAX(1);
662
663 /* Store the LINEAR address in DX:BX */
664 setDX(HIWORD(Address));
665 setBX(LOWORD(Address));
666 }
667 else
668 {
669 setAX(0);
670 setBL(Result);
671 }
672
673 break;
674 }
675
676 /* Unlock Extended Memory Block */
677 case 0x0D:
678 {
679 UCHAR Result = XmsUnlock(getDX());
680
681 setAX(Result == XMS_STATUS_SUCCESS);
682 setBL(Result);
683 break;
684 }
685
686 /* Get Handle Information */
687 case 0x0E:
688 {
689 PXMS_HANDLE HandleEntry = GetHandleRecord(getDX());
690 UINT i;
691 UCHAR Handles = 0;
692
693 if (!ValidateHandle(HandleEntry))
694 {
695 setAX(0);
696 setBL(XMS_STATUS_INVALID_HANDLE);
697 break;
698 }
699
700 for (i = 0; i < XMS_MAX_HANDLES; i++)
701 {
702 if (HandleTable[i].Handle == 0) Handles++;
703 }
704
705 setAX(1);
706 setBH(HandleEntry->LockCount);
707 setBL(Handles);
708 setDX(HandleEntry->Size);
709 break;
710 }
711
712 /* Reallocate Extended Memory Block */
713 case 0x0F:
714 {
715 UCHAR Result = XmsRealloc(getDX(), getBX());
716
717 setAX(Result == XMS_STATUS_SUCCESS);
718 setBL(Result);
719 break;
720 }
721
722 /* Request UMB */
723 case 0x10:
724 {
725 BOOLEAN Result;
726 USHORT Segment = 0x0000; /* No preferred segment */
727 USHORT Size = getDX(); /* Size is in paragraphs */
728
729 Result = UmaDescReserve(&Segment, &Size);
730 if (Result)
731 setBX(Segment);
732 else
733 setBL(Size > 0 ? XMS_STATUS_SMALLER_UMB : XMS_STATUS_OUT_OF_UMBS);
734
735 setDX(Size);
736 setAX(Result);
737 break;
738 }
739
740 /* Release UMB */
741 case 0x11:
742 {
743 BOOLEAN Result;
744 USHORT Segment = getDX();
745
746 Result = UmaDescRelease(Segment);
747 if (!Result)
748 setBL(XMS_STATUS_INVALID_UMB);
749
750 setAX(Result);
751 break;
752 }
753
754 /* Reallocate UMB */
755 case 0x12:
756 {
757 BOOLEAN Result;
758 USHORT Segment = getDX();
759 USHORT Size = getBX(); /* Size is in paragraphs */
760
761 Result = UmaDescReallocate(Segment, &Size);
762 if (!Result)
763 {
764 if (Size > 0)
765 {
766 setBL(XMS_STATUS_SMALLER_UMB);
767 setDX(Size);
768 }
769 else
770 {
771 setBL(XMS_STATUS_INVALID_UMB);
772 }
773 }
774
775 setAX(Result);
776 break;
777 }
778
779 default:
780 {
781 DPRINT1("XMS command AH = 0x%02X NOT IMPLEMENTED\n", getAH());
782 setBL(XMS_STATUS_NOT_IMPLEMENTED);
783 }
784 }
785 }
786
787 /* PUBLIC FUNCTIONS ***********************************************************/
788
789 BOOLEAN XmsGetDriverEntry(PDWORD Pointer)
790 {
791 if (Node == NULL) return FALSE;
792 *Pointer = DEVICE_PRIVATE_AREA(Node->Driver);
793 return TRUE;
794 }
795
796 VOID XmsInitialize(VOID)
797 {
798 RtlZeroMemory(HandleTable, sizeof(HandleTable));
799 RtlZeroMemory(BitmapBuffer, sizeof(BitmapBuffer));
800 RtlInitializeBitMap(&AllocBitmap, BitmapBuffer, XMS_BLOCKS);
801
802 Node = DosCreateDeviceEx(DOS_DEVATTR_IOCTL | DOS_DEVATTR_CHARACTER,
803 XMS_DEVICE_NAME,
804 sizeof(EntryProcedure));
805
806 RegisterBop(BOP_XMS, XmsBopProcedure);
807
808 /* Copy the entry routine to the device private area */
809 RtlMoveMemory(FAR_POINTER(DEVICE_PRIVATE_AREA(Node->Driver)),
810 EntryProcedure,
811 sizeof(EntryProcedure));
812 }
813
814 VOID XmsCleanup(VOID)
815 {
816 RegisterBop(BOP_XMS, NULL);
817 DosDeleteDevice(Node);
818 }