![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mono.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / q_a / samples / ddk / mono|
Return to mono.c CVS log | Up to [WindowsNT SDKs] / q_a / samples / ddk / mono |
1.1 root 1: /*++
2:
3: Copyright (c) 1993 Microsoft Corporation
4:
5: Module Name:
6:
7: mono.c
8:
9: Abstract:
10:
11: A simple kernel-mode driver sample.
12:
13: Environment:
14:
15: kernel mode only
16:
17: Notes:
18:
19: See readme.txt
20:
21: Revision History:
22:
23: 03-22-93 : created
24: 06-02-93 : #ifdef's removed from IoCreateSymbolicLink, and
25: bulk of pMonoReportResourceUsage commented out for
26: ease of use with other drivers (see note below)
27: --*/
28:
29: #include "ntddk.h"
30: #include "stdarg.h"
31: #include "stdio.h"
32: #include "monopub.h"
33: #include "monopriv.h"
34:
35:
36:
37: //
38: // NOTE: Routines prefixed with "p" are private to this module
39: //
40:
41: NTSTATUS
42: MonoDispatch(
43: IN PDEVICE_OBJECT DeviceObject,
44: IN PIRP Irp
45: );
46:
47: VOID
48: MonoUnload(
49: IN PDRIVER_OBJECT DriverObject
50: );
51:
52: NTSTATUS
53: pMonoLocateDevice(
54: void
55: );
56:
57: PVOID
58: pMonoGetMappedAddress(
59: IN PHYSICAL_ADDRESS PhysicalAddress,
60: IN ULONG AddressSpace,
61: IN ULONG NumberOfBytes
62: );
63:
64: BOOLEAN
65: pMonoReportResourceUsage(
66: IN PDRIVER_OBJECT DriverObject,
67: IN PMONO_RESOURCE MonoResources,
68: IN ULONG NumberOfResources
69: );
70:
71: VOID
72: MonoDbgPrint(
73: IN ULONG DbgPrintLevel,
74: IN PUCHAR DbgMessage,
75: IN ...
76: );
77:
78: VOID
79: pMonoPrint(
80: IN PMONO_DEVICE_EXTENSION DeviceExtension,
81: IN PUCHAR TextString,
82: IN ULONG BytesToMove
83: );
84:
85: VOID
86: pMonoClearScreen(
87: IN PMONO_DEVICE_EXTENSION DeviceExtension
88: );
89:
90:
91:
92: NTSTATUS
93: DriverEntry(
94: IN PDRIVER_OBJECT DriverObject,
95: IN PUNICODE_STRING RegistryPath
96: )
97: /*++
98:
99: Routine Description:
100:
101: Installable driver initialization entry point.
102: This entry point is called directly by the I/O system.
103:
104: Arguments:
105:
106: DriverObject - pointer to the driver object
107:
108: RegistryPath - pointer to a unicode string representing the path
109: to driver-specific key in the registry
110:
111: Return Value:
112:
113: STATUS_SUCCESS if successful,
114: STATUS_UNSUCCESSFUL otherwise
115:
116: --*/
117: {
118:
119: PDEVICE_OBJECT deviceObject = NULL;
120: NTSTATUS ntStatus;
121: WCHAR deviceNameBuffer[] = L"\\Device\\Mono";
122: UNICODE_STRING deviceNameUnicodeString;
123: PMONO_DEVICE_EXTENSION deviceExtension;
124: BOOLEAN symbolicLinkCreated = FALSE;
125: WCHAR deviceLinkBuffer[] = L"\\DosDevices\\MONO";
126: UNICODE_STRING deviceLinkUnicodeString;
127:
128:
129: pMonoKdPrint (("MONO.SYS: entering DriverEntry\n"));
130:
131:
132:
133: //
134: // Check to see if anybody else has claim the resources we want to
135: // used. We don't want to be partying on someone else's hardware,
136: // even when trying to locate our devicc.
137: //
138:
139: if (!pMonoReportResourceUsage (DriverObject,
140: MonoResources,
141: MONO_NUMBER_RESOURCE_ENTRIES
142: ))
143: {
144: //
145: // There's a resource conflict
146: //
147:
148: pMonoKdPrint (("MONO.SYS: pMonoReportResourceUsage failed\n"));
149:
150: return STATUS_UNSUCCESSFUL;
151: }
152:
153:
154:
155: //
156: // Try to locate a monochrome display adapter (MDA)
157: //
158:
159: ntStatus = pMonoLocateDevice ();
160:
161: if (!NT_SUCCESS(ntStatus))
162: {
163: pMonoKdPrint (("MONO.SYS: pMonoLocateDevice failed\n"));
164:
165: ntStatus = STATUS_UNSUCCESSFUL;
166:
167: goto done_DriverEntry;
168: }
169:
170:
171:
172: //
173: // OK, we've claimed our resources & found our h/w, so create
174: // a device and initialize stuff...
175: //
176:
177: RtlInitUnicodeString (&deviceNameUnicodeString,
178: deviceNameBuffer
179: );
180:
181:
182:
183: //
184: // Create an EXCLUSIVE device, i.e. only 1 thread at a time can send
185: // i/o requests. If opened as non-exclusive, then we would need to
186: // implement a more robust synchronization scheme than the event
187: // mechanism we utilize below.
188: //
189:
190: ntStatus = IoCreateDevice (DriverObject,
191: sizeof (MONO_DEVICE_EXTENSION),
192: &deviceNameUnicodeString,
193: FILE_DEVICE_MONO,
194: 0,
195: TRUE,
196: &deviceObject
197: );
198:
199: if (NT_SUCCESS(ntStatus))
200: {
201:
202: GlobalDeviceExtension =
203: deviceExtension = (PMONO_DEVICE_EXTENSION) deviceObject->DeviceExtension;
204:
205:
206: //
207: // Initialize the dispatch event object. This allows us to
208: // synchronize access to the h/w registers...
209: //
210:
211: KeInitializeEvent (&deviceExtension->SyncEvent,
212: SynchronizationEvent,
213: TRUE
214: );
215:
216:
217:
218: deviceExtension->InterfaceType = Isa;
219: deviceExtension->BusNumber = 0;
220:
221:
222: //
223: // Map all the required resources, save the addresses
224: //
225:
226: deviceExtension->VideoMemory =
227:
228: (PUSHORT) pMonoGetMappedAddress (MonoResources[MONO_VIDEO_BUFFER].PhysicalAddress,
229: MonoResources[MONO_VIDEO_BUFFER].AddressSpace,
230: MonoResources[MONO_VIDEO_BUFFER].Length
231: );
232:
233: deviceExtension->CRTCRegisters =
234:
235: (PUCHAR) pMonoGetMappedAddress (MonoResources[MONO_CRTC_REG].PhysicalAddress,
236: MonoResources[MONO_CRTC_REG].AddressSpace,
237: MonoResources[MONO_CRTC_REG].Length
238: );
239:
240: deviceExtension->ModeControlRegister =
241:
242: (PUCHAR) pMonoGetMappedAddress (MonoResources[MONO_MODE_CTL_REG].PhysicalAddress,
243: MonoResources[MONO_MODE_CTL_REG].AddressSpace,
244: MonoResources[MONO_MODE_CTL_REG].Length
245: );
246:
247: if (!deviceExtension->VideoMemory ||
248: !deviceExtension->CRTCRegisters ||
249: !deviceExtension->ModeControlRegister
250: )
251: {
252:
253: pMonoKdPrint (("MONO.SYS: pMonoGetMappedAddress failed\n"));
254:
255: ntStatus = STATUS_UNSUCCESSFUL;
256:
257: goto done_DriverEntry;
258:
259: }
260:
261: deviceExtension->Xpos =
262: deviceExtension->Ypos = 0;
263:
264:
265:
266: //
267: // Create a symbolic link that Win32 apps can specify to gain access
268: // to this driver/device
269: //
270:
271: RtlInitUnicodeString (&deviceLinkUnicodeString,
272: deviceLinkBuffer
273: );
274:
275: ntStatus = IoCreateSymbolicLink (&deviceLinkUnicodeString,
276: &deviceNameUnicodeString
277: );
278:
279:
280: if (!NT_SUCCESS(ntStatus))
281: {
282: pMonoKdPrint (("MONO.SYS: IoCreateSymbolicLink failed\n"));
283: }
284: else
285: {
286: symbolicLinkCreated = TRUE;
287: }
288:
289:
290:
291: //
292: // Create dispatch points for device control, create, close.
293: //
294:
295: DriverObject->MajorFunction[IRP_MJ_CREATE] =
296: DriverObject->MajorFunction[IRP_MJ_CLOSE] =
297: DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = MonoDispatch;
298: DriverObject->DriverUnload = MonoUnload;
299:
300:
301:
302: //
303: // Set the Start Address registers (indicate which part of
304: // video buffer is displayed) to 0
305: //
306:
307: WRITE_PORT_UCHAR (deviceExtension->CRTCRegisters, 0xc);
308: WRITE_PORT_UCHAR (deviceExtension->CRTCRegisters + 1, 0);
309: WRITE_PORT_UCHAR (deviceExtension->CRTCRegisters, 0xd);
310: WRITE_PORT_UCHAR (deviceExtension->CRTCRegisters + 1, 0);
311:
312:
313:
314: //
315: // Clear screen & alert world of our humble existence
316: //
317:
318: pMonoClearScreen (deviceExtension);
319:
320: #define INIT_STRING "Mono driver initialized\n"
321:
322: pMonoPrint (deviceExtension,
323: INIT_STRING,
324: sizeof (INIT_STRING)
325: );
326: }
327:
328:
329: done_DriverEntry:
330:
331: if (!NT_SUCCESS(ntStatus))
332: {
333: //
334: // Something went wrong, so clean up
335: //
336:
337: pMonoReportResourceUsage (DriverObject,
338: NULL,
339: 0
340: );
341:
342: if (symbolicLinkCreated)
343:
344: IoDeleteSymbolicLink (&deviceLinkUnicodeString);
345:
346:
347: if (deviceObject)
348:
349: IoDeleteDevice (deviceObject);
350:
351: GlobalDeviceExtension = NULL;
352: }
353:
354: return ntStatus;
355: }
356:
357:
358:
359: NTSTATUS
360: MonoDispatch(
361: IN PDEVICE_OBJECT DeviceObject,
362: IN PIRP Irp
363: )
364: /*++
365:
366: Routine Description:
367:
368: Process the IRPs sent to this device.
369:
370: Arguments:
371:
372: DeviceObject - pointer to a device object
373:
374: Irp - pointer to an I/O Request Packet
375:
376: Return Value:
377:
378:
379: --*/
380: {
381:
382: PIO_STACK_LOCATION irpStack;
383: PMONO_DEVICE_EXTENSION deviceExtension;
384: PVOID ioBuffer;
385: ULONG inputBufferLength;
386: ULONG outputBufferLength;
387: ULONG ioControlCode;
388: NTSTATUS ntStatus;
389:
390:
391:
392: Irp->IoStatus.Status = STATUS_SUCCESS;
393: Irp->IoStatus.Information = 0;
394:
395:
396: //
397: // Get a pointer to the current location in the Irp. This is where
398: // the function codes and parameters are located.
399: //
400:
401: irpStack = IoGetCurrentIrpStackLocation (Irp);
402:
403:
404:
405: //
406: // Get a pointer to the device extension
407: //
408:
409: deviceExtension = DeviceObject->DeviceExtension;
410:
411:
412:
413: //
414: // Get the pointer to the input/output buffer and it's length
415: //
416:
417: ioBuffer = Irp->AssociatedIrp.SystemBuffer;
418: inputBufferLength = irpStack->Parameters.DeviceIoControl.InputBufferLength;
419: outputBufferLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
420:
421:
422:
423: //
424: // Synchronize execution of the dispatch routine by acquiring the device
425: // event object. This ensures all request are serialized.
426: //
427:
428: KeWaitForSingleObject (&deviceExtension->SyncEvent,
429: Executive,
430: KernelMode,
431: FALSE,
432: (PTIME) NULL
433: );
434:
435:
436:
437: switch (irpStack->MajorFunction)
438: {
439: case IRP_MJ_CREATE:
440:
441: pMonoKdPrint (("MONO.SYS: IRP_MJ_CREATE\n"));
442:
443: break;
444:
445: case IRP_MJ_CLOSE:
446:
447: pMonoKdPrint (("MONO.SYS: IRP_MJ_CLOSE\n"));
448:
449: break;
450:
451: case IRP_MJ_DEVICE_CONTROL:
452:
453: pMonoKdPrint (("MONO.SYS: IRP_MJ_DEVICE_CONTROL\n"));
454:
455: ioControlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;
456:
457: switch (ioControlCode)
458: {
459:
460: case IOCTL_MONO_PRINT:
461: {
462: pMonoPrint (deviceExtension,
463: ioBuffer,
464: inputBufferLength
465: );
466:
467: break;
468: }
469:
470: case IOCTL_MONO_CLEAR_SCREEN:
471: {
472: pMonoClearScreen (deviceExtension);
473:
474: break;
475: }
476:
477: default:
478:
479: Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
480:
481: pMonoKdPrint (("MONO.SYS: unknown IRP_MJ_DEVICE_CONTROL\n"));
482:
483: break;
484:
485: }
486:
487: break;
488: }
489:
490:
491: KeSetEvent (&deviceExtension->SyncEvent,
492: 0,
493: FALSE
494: );
495:
496: //
497: // DON'T get cute and try to use the status field of
498: // the irp in the return status. That IRP IS GONE as
499: // soon as you call IoCompleteRequest.
500: //
501:
502: ntStatus = Irp->IoStatus.Status;
503:
504: IoCompleteRequest (Irp,
505: IO_NO_INCREMENT
506: );
507:
508:
509: //
510: // We never have pending operation so always return the status code.
511: //
512:
513: return ntStatus;
514: }
515:
516:
517:
518: VOID
519: MonoUnload(
520: IN PDRIVER_OBJECT DriverObject
521: )
522: /*++
523:
524: Routine Description:
525:
526: Free all the allocated resources, etc.
527:
528: Arguments:
529:
530: DriverObject - pointer to a driver object
531:
532: Return Value:
533:
534:
535: --*/
536: {
537: WCHAR deviceLinkBuffer[] = L"\\DosDevices\\MONO";
538: UNICODE_STRING deviceLinkUnicodeString;
539:
540:
541: //
542: // Unreport the resources
543: //
544:
545: pMonoReportResourceUsage (DriverObject,
546: NULL,
547: 0
548: );
549:
550:
551:
552: //
553: // Delete the symbolic link
554: //
555:
556: RtlInitUnicodeString (&deviceLinkUnicodeString,
557: deviceLinkBuffer
558: );
559:
560: IoDeleteSymbolicLink (&deviceLinkUnicodeString);
561:
562:
563:
564:
565: //
566: // Delete the device object
567: //
568:
569: IoDeleteDevice (DriverObject->DeviceObject);
570:
571: pMonoKdPrint (("MONO.SYS: unloading\n"));
572: }
573:
574:
575:
576: NTSTATUS
577: pMonoLocateDevice(
578: )
579: /*++
580:
581: Routine Description:
582:
583: Attempts to locate an MDA
584:
585: Arguments:
586:
587:
588: Return Value:
589:
590: STATUS_SUCCESS if adapter found,
591: STATUS_UNSUCCESSFUL otherwise
592:
593: --*/
594: {
595:
596: NTSTATUS ntStatus = STATUS_SUCCESS;
597: PHYSICAL_ADDRESS physicalAddress;
598: PUCHAR crtcRegisters;
599:
600: //
601: // Our FindAdapter logic:
602: //
603: // - retrieve an address for the 6845's index register (0x3b4)
604: // - write a 0x0f to the index register (0x0f = index of Cursor
605: // Location Low register)
606: // - write a 0x55 to 0x3b5
607: // - read 0x3b5, and it should == 0x55
608: //
609:
610: physicalAddress.LowPart = 0x3b4;
611: physicalAddress.HighPart = 0;
612:
613:
614: if ((crtcRegisters = pMonoGetMappedAddress (physicalAddress,
615: 1,
616: 2
617: )))
618: {
619: WRITE_PORT_UCHAR (crtcRegisters, 0x0f);
620: WRITE_PORT_UCHAR (crtcRegisters + 1, 0x55);
621:
622: if (READ_PORT_UCHAR (crtcRegisters + 1) != 0x55)
623: {
624: pMonoKdPrint (("MONO.SYS: could not find adapter\n"));
625:
626: ntStatus = STATUS_UNSUCCESSFUL;
627:
628: goto done_LocateDevice;
629: }
630:
631: //
632: // Set current cursor location back to (0,0)
633: //
634:
635: WRITE_PORT_UCHAR (crtcRegisters + 1, 0x00);
636: }
637:
638: else
639: {
640: pMonoKdPrint (("MONO.SYS: HalTranslatedAddress(0x3b4) failed\n"));
641:
642: ntStatus = STATUS_UNSUCCESSFUL;
643: }
644:
645: done_LocateDevice:
646:
647: return ntStatus;
648: }
649:
650:
651:
652: PVOID
653: pMonoGetMappedAddress(
654: IN PHYSICAL_ADDRESS PhysicalAddress,
655: IN ULONG AddressSpace,
656: IN ULONG NumberOfBytes
657: )
658: /*++
659:
660: Routine Description:
661:
662: Given a physical address, retrieves a corresponding system address
663: that can be used by a kernel mode driver.
664:
665: Arguments:
666:
667: PhysicalAddress - physical address to map
668:
669: AddressSpace - 0 if in memory space, 1 if in I/O space
670:
671: NumberOfBytes - length of section to map
672:
673: Return Value:
674:
675: A valid system address is successful,
676: NULL otherwise.
677:
678: --*/
679: {
680: //
681: // Assume we're on Isa bus # 0
682: //
683:
684: IN INTERFACE_TYPE interfaceType = Isa;
685: IN ULONG busNumber = 0;
686: PHYSICAL_ADDRESS translatedAddress;
687: PVOID deviceBase = NULL;
688:
689: if (HalTranslateBusAddress (interfaceType,
690: busNumber,
691: PhysicalAddress,
692: &AddressSpace,
693: &translatedAddress
694: ))
695: {
696: if (!AddressSpace)
697: {
698: if (!(deviceBase = MmMapIoSpace (translatedAddress,
699: NumberOfBytes,
700: FALSE // noncached memory
701: )))
702: {
703: pMonoKdPrint (("MONO.SYS: MmMapIoSpaceFailed\n"));
704: }
705: }
706: else
707: {
708: deviceBase = (PVOID) translatedAddress.LowPart;
709: }
710: }
711:
712: else
713: {
714: pMonoKdPrint (("MONO.SYS: HalTranslateBusAddress failed\n"));
715: }
716:
717: return deviceBase;
718: }
719:
720:
721:
722: BOOLEAN
723: pMonoReportResourceUsage(
724: IN PDRIVER_OBJECT DriverObject,
725: IN PMONO_RESOURCE MonoResources,
726: IN ULONG NumberOfResources
727: )
728: /*++
729:
730: Routine Description:
731:
732: Reports the resources used by a device.
733:
734: Arguments:
735:
736: DriverObject - pointer to a driver object
737:
738: MonoResources - pointer to an array of resource information, or
739: NULL is unreporting resources for this driver
740:
741: NumberOfResources - number of entries in the resource array, or
742: 0 if unreporting resources for this driver
743:
744: Return Value:
745:
746: TRUE if resources successfully report (and no conflicts),
747: FALSE otherwise.
748:
749: --*/
750: {
751:
752:
753:
754: //
755: // NOTE: The following is commented out because some of the video miniport
756: // drivers provided with the system (and in the NT DDK) regsister
757: // their resources as exclusive; if these resources overlap with
758: // the resources used by the mono driver, then this driver will fail
759: // to load. This can be solved in one of two ways: by commenting
760: // out the code below, and using the resources without reporting them
761: // (not safe to do, but the easiest for this simple example); or, by
762: // editing the source file(s) of the appropriate miniport driver
763: // such that the VIDEO_ACCESS_RANGE.RangeSharable element is set to
764: // TRUE, and rebuilding the driver.
765: //
766: // A real driver should *always* report it's resources.
767: //
768:
769:
770: /*
771: ULONG sizeOfResourceList = 0;
772: PCM_RESOURCE_LIST resourceList = NULL;
773: PCM_PARTIAL_RESOURCE_DESCRIPTOR partial;
774: ULONG i;
775: UNICODE_STRING className;
776: BOOLEAN conflictDetected;
777:
778:
779: if (NumberOfResources > 0)
780: {
781: //
782: // Alloc enough memory to build a resource list & zero it out
783: //
784:
785: sizeOfResourceList = sizeof(CM_RESOURCE_LIST) +
786: (sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR)*
787: (NumberOfResources - 1)
788: );
789:
790: resourceList = ExAllocatePool (PagedPool,
791: sizeOfResourceList
792: );
793:
794: if (!resourceList)
795: {
796: pMonoKdPrint (("MONO.SYS: ExAllocPool failed\n"));
797:
798: return FALSE;
799: }
800:
801: RtlZeroMemory (resourceList,
802: sizeOfResourceList
803: );
804:
805:
806: //
807: // Fill in the reosurce list
808: //
809: // NOTE: Assume Isa, bus # 0
810: //
811:
812: resourceList->Count = 1;
813:
814: resourceList->List[0].InterfaceType = Isa;
815: resourceList->List[0].BusNumber = 0;
816:
817: resourceList->List[0].PartialResourceList.Count = NumberOfResources;
818:
819: partial = &resourceList->List[0].PartialResourceList.PartialDescriptors[0];
820:
821: //
822: // Account for the space used by the controller.
823: //
824:
825: for (i = 0; i < NumberOfResources; i++)
826: {
827: if (MonoResources[i].AddressSpace)
828: {
829: partial->Type = CmResourceTypePort;
830: partial->Flags = CM_RESOURCE_PORT_IO;
831: partial->u.Port.Start = MonoResources[i].PhysicalAddress;
832: partial->u.Port.Length = MonoResources[i].Length;
833: }
834: else
835: {
836: partial->Type = CmResourceTypeMemory;
837: partial->Flags = CM_RESOURCE_MEMORY_READ_WRITE;
838: partial->u.Memory.Start = MonoResources[i].PhysicalAddress;
839: partial->u.Memory.Length = MonoResources[i].Length;
840: }
841:
842: if (MonoResources[i].RangeSharable)
843: {
844: partial->ShareDisposition = CmResourceShareShared;
845: }
846:
847: else
848: {
849: partial->ShareDisposition = CmResourceShareDeviceExclusive;
850: }
851:
852: partial++;
853: }
854: }
855:
856: RtlInitUnicodeString (&className,
857: L"LOADED MONO DRIVER RESOURCES"
858: );
859:
860: IoReportResourceUsage (&className,
861: DriverObject,
862: resourceList,
863: sizeOfResourceList,
864: NULL,
865: NULL,
866: 0,
867: FALSE,
868: &conflictDetected
869: );
870:
871: if (resourceList)
872: {
873: ExFreePool (resourceList);
874:
875:
876: if (conflictDetected)
877:
878: return FALSE;
879:
880: else
881:
882: return TRUE;
883: }
884: */
885: return TRUE;
886: }
887:
888:
889:
890: VOID
891: MonoDbgPrint(
892: IN ULONG DbgPrintLevel,
893: IN PUCHAR DbgMessage,
894: IN ...
895: )
896: /*++
897:
898: Routine Description:
899:
900: Format the incoming debug message & calls pMonoPrint to write the
901: message out to the attached MDA.
902:
903: Arguments:
904:
905: DbgPrintLevel - level of message verboseness
906:
907: DbgMessage - printf-style format string, followed by appropriate
908: list of arguments
909:
910: Return Value:
911:
912:
913: --*/
914: {
915: va_list ap;
916:
917: va_start(ap, DbgMessage);
918:
919: if (DbgPrintLevel <= MonoDbgLevel)
920: {
921: char buf[256];
922:
923: vsprintf (buf,
924: DbgMessage,
925: ap
926: );
927:
928: if (GlobalDeviceExtension)
929:
930: pMonoPrint (GlobalDeviceExtension,
931: buf,
932: strlen (buf)
933: );
934: }
935:
936: va_end(ap);
937: }
938:
939:
940:
941: VOID
942: pMonoPrint(
943: IN PMONO_DEVICE_EXTENSION DeviceExtension,
944: IN PUCHAR TextString,
945: IN ULONG BytesToMove
946: )
947: /*++
948:
949: Routine Description:
950:
951: Writes a specified string to MDA memory
952:
953: Arguments:
954:
955: DeviceExtension - pointer to a device extension
956:
957: TextString - pointer to an ascii string
958:
959: BytesToMove - number of characters to write
960:
961: Return Value:
962:
963:
964: --*/
965: {
966:
967: PUSHORT VideoMemory;
968: ULONG x,y,i,j;
969: UCHAR Letter;
970:
971: VideoMemory = DeviceExtension->VideoMemory;
972: x = DeviceExtension->Xpos;
973: y = DeviceExtension->Ypos;
974:
975:
976: for (i = 0; i < BytesToMove; i++)
977: {
978: Letter = (UCHAR) *(TextString + i);
979:
980: if (Letter == '\n')
981: {
982: //
983: // Blank out the rest of the line
984: //
985:
986: for (j = x; j < 80; j++)
987: {
988: *(VideoMemory + j + (y * 80)) = 0;
989: }
990: x = 0;
991: y = y + 1;
992: }
993:
994: else
995: {
996: //
997: // Write character & attribute out to video memory
998: //
999: // 0x0700 = No blink, black background, normal intensity,
1000: // white chracter
1001: //
1002:
1003: *(VideoMemory + x + (y * 80)) = Letter | 0x0700;
1004:
1005: x++;
1006: }
1007:
1008: if (x > 79)
1009: {
1010: //
1011: // Wrap around to next line
1012: //
1013:
1014: x = 0;
1015: y++;
1016: }
1017:
1018: if (y > 24)
1019: {
1020: //
1021: // We've reached the bottom of the screen, scroll screen
1022: // up by 1 row
1023: //
1024:
1025: RtlMoveMemory (VideoMemory,
1026: VideoMemory+80,
1027: 24 * 80 * 2
1028: );
1029: y = 24;
1030:
1031:
1032: //
1033: // Zero out the bottom row
1034: //
1035:
1036: for (j = 0; j < 80; j++)
1037: {
1038: *(VideoMemory + j + (24 * 80)) = 0;
1039: }
1040: }
1041: }
1042:
1043: DeviceExtension->Xpos = x;
1044: DeviceExtension->Ypos = y;
1045: }
1046:
1047:
1048:
1049: VOID
1050: pMonoClearScreen(
1051: IN PMONO_DEVICE_EXTENSION DeviceExtension
1052: )
1053: /*++
1054:
1055: Routine Description:
1056:
1057: Clears the MDA
1058:
1059: Arguments:
1060:
1061:
1062: Return Value:
1063:
1064:
1065: --*/
1066: {
1067:
1068: ULONG i;
1069:
1070: //
1071: // Zero out the MDA memory
1072: //
1073:
1074: for (i = 0; i < 25 * 80; i++)
1075:
1076: *(DeviceExtension->VideoMemory + i) = 0;
1077:
1078: DeviceExtension->Xpos =
1079: DeviceExtension->Ypos = 0;
1080: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.