![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to modeset.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / miniport / wdvga|
Return to modeset.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / miniport / wdvga |
1.1 root 1: /*++
2:
3: Copyright (c) 1992 Microsoft Corporation
4:
5: Module Name:
6:
7: modeset.c
8:
9: Abstract:
10:
11: This is the modeset code for the WD VGA miniport driver.
12:
13: Environment:
14:
15: kernel mode only
16:
17: Notes:
18:
19: Revision History:
20:
21: --*/
22: #include "dderror.h"
23: #include "devioctl.h"
24: #include "miniport.h"
25:
26: #include "ntddvdeo.h"
27: #include "video.h"
28: #include "wdvga.h"
29: #include "modeset.h"
30:
31: VOID
32: VgaZeroVideoMemory(
33: PHW_DEVICE_EXTENSION HwDeviceExtension
34: );
35:
36:
37: VP_STATUS
38: VgaInterpretCmdStream(
39: PHW_DEVICE_EXTENSION HwDeviceExtension,
40: PUSHORT pusCmdStream
41: )
42:
43: /*++
44:
45: Routine Description:
46:
47: Interprets the appropriate command array to set up VGA registers for the
48: requested mode. Typically used to set the VGA into a particular mode by
49: programming all of the registers
50:
51: Arguments:
52:
53: HwDeviceExtension - Pointer to the miniport driver's device extension.
54:
55: pusCmdStream - array of commands to be interpreted.
56:
57: Return Value:
58:
59: The status of the operation (can only fail on a bad command); TRUE for
60: success, FALSE for failure.
61:
62: --*/
63:
64: {
65: ULONG ulCmd;
66: ULONG ulPort;
67: UCHAR jValue;
68: USHORT usValue;
69: ULONG culCount;
70: ULONG ulIndex;
71: ULONG ulBase;
72:
73: if (pusCmdStream == NULL) {
74:
75: VideoDebugPrint((1, "VgaInterpretCmdStream - Invalid pusCmdStream\n"));
76: return TRUE;
77: }
78:
79: ulBase = (ULONG)HwDeviceExtension->IOAddress;
80:
81: //
82: // Now set the adapter to the desired mode.
83: //
84:
85: while ((ulCmd = *pusCmdStream++) != EOD) {
86:
87: //
88: // Determine major command type
89: //
90:
91: switch (ulCmd & 0xF0) {
92:
93: //
94: // Basic input/output command
95: //
96:
97: case INOUT:
98:
99: //
100: // Determine type of inout instruction
101: //
102:
103: if (!(ulCmd & IO)) {
104:
105: //
106: // Out instruction. Single or multiple outs?
107: //
108:
109: if (!(ulCmd & MULTI)) {
110:
111: //
112: // Single out. Byte or word out?
113: //
114:
115: if (!(ulCmd & BW)) {
116:
117: //
118: // Single byte out
119: //
120:
121: ulPort = *pusCmdStream++;
122: jValue = (UCHAR) *pusCmdStream++;
123: VideoPortWritePortUchar((PUCHAR)(ulBase+ulPort),
124: jValue);
125:
126: } else {
127:
128: //
129: // Single word out
130: //
131:
132: ulPort = *pusCmdStream++;
133: usValue = *pusCmdStream++;
134: VideoPortWritePortUshort((PUSHORT)(ulBase+ulPort),
135: usValue);
136:
137: }
138:
139: } else {
140:
141: //
142: // Output a string of values
143: // Byte or word outs?
144: //
145:
146: if (!(ulCmd & BW)) {
147:
148: //
149: // String byte outs. Do in a loop; can't use
150: // VideoPortWritePortBufferUchar because the data
151: // is in USHORT form
152: //
153:
154: ulPort = ulBase + *pusCmdStream++;
155: culCount = *pusCmdStream++;
156:
157: while (culCount--) {
158: jValue = (UCHAR) *pusCmdStream++;
159: VideoPortWritePortUchar((PUCHAR)ulPort,
160: jValue);
161:
162: }
163:
164: } else {
165:
166: //
167: // String word outs
168: //
169:
170: ulPort = *pusCmdStream++;
171: culCount = *pusCmdStream++;
172: VideoPortWritePortBufferUshort((PUSHORT)
173: (ulBase + ulPort), pusCmdStream, culCount);
174: pusCmdStream += culCount;
175:
176: }
177: }
178:
179: } else {
180:
181: // In instruction
182: //
183: // Currently, string in instructions aren't supported; all
184: // in instructions are handled as single-byte ins
185: //
186: // Byte or word in?
187: //
188:
189: if (!(ulCmd & BW)) {
190: //
191: // Single byte in
192: //
193:
194: ulPort = *pusCmdStream++;
195: jValue = VideoPortReadPortUchar((PUCHAR)ulBase+ulPort);
196:
197: } else {
198:
199: //
200: // Single word in
201: //
202:
203: ulPort = *pusCmdStream++;
204: usValue = VideoPortReadPortUshort((PUSHORT)
205: (ulBase+ulPort));
206:
207: }
208:
209: }
210:
211: break;
212:
213: //
214: // Higher-level input/output commands
215: //
216:
217: case METAOUT:
218:
219: //
220: // Determine type of metaout command, based on minor
221: // command field
222: //
223: switch (ulCmd & 0x0F) {
224:
225: //
226: // Indexed outs
227: //
228:
229: case INDXOUT:
230:
231: ulPort = ulBase + *pusCmdStream++;
232: culCount = *pusCmdStream++;
233: ulIndex = *pusCmdStream++;
234:
235: while (culCount--) {
236:
237: usValue = (USHORT) (ulIndex +
238: (((ULONG)(*pusCmdStream++)) << 8));
239: VideoPortWritePortUshort((PUSHORT)ulPort, usValue);
240:
241: ulIndex++;
242:
243: }
244:
245: break;
246:
247: //
248: // Masked out (read, AND, XOR, write)
249: //
250:
251: case MASKOUT:
252:
253: ulPort = *pusCmdStream++;
254: jValue = VideoPortReadPortUchar((PUCHAR)ulBase+ulPort);
255: jValue &= *pusCmdStream++;
256: jValue ^= *pusCmdStream++;
257: VideoPortWritePortUchar((PUCHAR)ulBase + ulPort,
258: jValue);
259: break;
260:
261: //
262: // Attribute Controller out
263: //
264:
265: case ATCOUT:
266:
267: ulPort = ulBase + *pusCmdStream++;
268: culCount = *pusCmdStream++;
269: ulIndex = *pusCmdStream++;
270:
271: while (culCount--) {
272:
273: // Write Attribute Controller index
274: VideoPortWritePortUchar((PUCHAR)ulPort,
275: (UCHAR)ulIndex);
276:
277: // Write Attribute Controller data
278: jValue = (UCHAR) *pusCmdStream++;
279: VideoPortWritePortUchar((PUCHAR)ulPort, jValue);
280:
281: ulIndex++;
282:
283: }
284:
285: break;
286:
287: //
288: // None of the above; error
289: //
290: default:
291:
292: return FALSE;
293:
294: }
295:
296:
297: break;
298:
299: //
300: // NOP
301: //
302:
303: case NCMD:
304:
305: break;
306:
307: //
308: // Unknown command; error
309: //
310:
311: default:
312:
313: return FALSE;
314:
315: }
316:
317: }
318:
319: return TRUE;
320:
321: } // end VgaInterpretCmdStream()
322:
323:
324: VP_STATUS
325: VgaSetMode(
326: PHW_DEVICE_EXTENSION HwDeviceExtension,
327: PVIDEO_MODE Mode,
328: ULONG ModeSize
329: )
330:
331: /*++
332:
333: Routine Description:
334:
335: This routine sets the VGA into the requested mode.
336:
337: Arguments:
338:
339: HwDeviceExtension - Pointer to the miniport driver's device extension.
340:
341: Mode - Pointer to the structure containing the information about the
342: font to be set.
343:
344: ModeSize - Length of the input buffer supplied by the user.
345:
346: Return Value:
347:
348: ERROR_INSUFFICIENT_BUFFER if the input buffer was not large enough
349: for the input data.
350:
351: ERROR_INVALID_PARAMETER if the mode number is invalid.
352:
353: NO_ERROR if the operation completed successfully.
354:
355: --*/
356:
357: {
358:
359: PVIDEOMODE pRequestedMode;
360: VP_STATUS status;
361: UCHAR temp;
362: UCHAR dummy;
363: UCHAR bIsColor;
364: VIDEO_X86_BIOS_ARGUMENTS biosArguments;
365: UCHAR frequencySetting;
366:
367: //
368: // Check if the size of the data in the input buffer is large enough.
369: //
370:
371: if (ModeSize < sizeof(VIDEO_MODE)) {
372:
373: return ERROR_INSUFFICIENT_BUFFER;
374:
375: }
376:
377: //
378: // Extract the clear memory bit.
379: //
380:
381: if (Mode->RequestedMode & VIDEO_MODE_NO_ZERO_MEMORY) {
382:
383: Mode->RequestedMode &= ~VIDEO_MODE_NO_ZERO_MEMORY;
384:
385: } else {
386:
387: VgaZeroVideoMemory(HwDeviceExtension);
388:
389: }
390:
391: //
392: // Check to see if we are requesting a valid mode
393: //
394:
395: if ( (Mode->RequestedMode >= NumVideoModes) ||
396: (!ModesVGA[Mode->RequestedMode].ValidMode) ) {
397:
398: return ERROR_INVALID_PARAMETER;
399:
400: }
401:
402: pRequestedMode = &ModesVGA[Mode->RequestedMode];
403:
404: //
405: // Make sure we unlock extended registers since the BIOS on some machines
406: // does not do it properly.
407: //
408:
409: VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
410: GRAPH_ADDRESS_PORT, 0x0F);
411:
412: VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
413: GRAPH_DATA_PORT, 0x05);
414:
415: #ifdef INT10_MODE_SET
416:
417: //
418: // First set up the frequency so the modeset grabs it properly.
419: //
420:
421: if (VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
422: MISC_OUTPUT_REG_READ_PORT) & 0x01) {
423:
424: bIsColor = TRUE;
425:
426: } else {
427:
428: bIsColor = FALSE;
429:
430: }
431:
432: if (bIsColor) {
433:
434: VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
435: CRTC_ADDRESS_PORT_COLOR, 0x2b);
436:
437: temp = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
438: CRTC_DATA_PORT_COLOR);
439:
440: } else {
441:
442: VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
443: CRTC_ADDRESS_PORT_MONO, 0x2b);
444:
445: temp = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
446: CRTC_DATA_PORT_MONO);
447:
448: }
449:
450: //
451: // Adjust the frequency setting register and write it back out.
452: // Also support Diamond changes to frequency settings
453: //
454:
455: temp &= pRequestedMode->FrequencyMask;
456:
457: frequencySetting = pRequestedMode->FrequencySetting;
458:
459:
460: if ( (HwDeviceExtension->BoardID == SPEEDSTAR31) &&
461: (pRequestedMode->hres == 1024) ) {
462:
463: //
464: // Diamond has inversed the refresh rates of interlaced and 72 Hz
465: // on the 1024 modes
466: //
467:
468: if (pRequestedMode->Frequency == 72) {
469:
470: frequencySetting = 0x00;
471:
472: } else {
473:
474: if (pRequestedMode->Frequency == 44) {
475:
476: frequencySetting = 0x30;
477:
478: }
479: }
480: }
481:
482: temp |= frequencySetting;
483:
484: if (bIsColor) {
485:
486: VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
487: CRTC_DATA_PORT_COLOR, temp);
488:
489: } else {
490:
491: VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
492: CRTC_DATA_PORT_MONO, temp);
493:
494: }
495:
496: //
497: // Set the mode
498: //
499:
500: VideoPortZeroMemory(&biosArguments, sizeof(VIDEO_X86_BIOS_ARGUMENTS));
501:
502: biosArguments.Eax = pRequestedMode->Int10ModeNumber;
503:
504: status = VideoPortInt10(HwDeviceExtension, &biosArguments);
505:
506: if (status != NO_ERROR) {
507:
508: return status;
509:
510: }
511:
512: if (pRequestedMode->CmdStrings != NULL) {
513:
514: VgaInterpretCmdStream(HwDeviceExtension, pRequestedMode->CmdStrings);
515:
516: }
517:
518: if (!(pRequestedMode->fbType & VIDEO_MODE_GRAPHICS)) {
519:
520: //
521: // Fix to make sure we always set the colors in text mode to be
522: // intensity, and not flashing
523: // For this zero out the Mode Control Regsiter bit 3 (index 0x10
524: // of the Attribute controller).
525: //
526:
527: if (bIsColor) {
528:
529: dummy = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
530: INPUT_STATUS_1_COLOR);
531: } else {
532:
533: dummy = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
534: INPUT_STATUS_1_MONO);
535: }
536:
537: VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
538: ATT_ADDRESS_PORT, (0x10 | VIDEO_ENABLE));
539: temp = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
540: ATT_DATA_READ_PORT);
541:
542: temp &= 0xF7;
543:
544: if (bIsColor) {
545:
546: dummy = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
547: INPUT_STATUS_1_COLOR);
548: } else {
549:
550: dummy = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
551: INPUT_STATUS_1_MONO);
552: }
553:
554: VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
555: ATT_ADDRESS_PORT, (0x10 | VIDEO_ENABLE));
556: VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
557: ATT_DATA_WRITE_PORT, temp);
558:
559: }
560:
561: #else
562: VgaInterpretCmdStream(HwDeviceExtension, pRequestedMode->CmdStrings);
563: #endif
564:
565: //
566: // Make sure we unlock extended registers since the BIOS on some machines
567: // does not do it properly.
568: //
569:
570: VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
571: GRAPH_ADDRESS_PORT, 0x0F);
572:
573: VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
574: GRAPH_DATA_PORT, 0x05);
575:
576: //
577: // Update the location of the physical frame buffer within video memory.
578: //
579:
580: HwDeviceExtension->PhysicalFrameLength =
581: MemoryMaps[pRequestedMode->MemMap].MaxSize;
582:
583: HwDeviceExtension->PhysicalFrameBase.LowPart =
584: MemoryMaps[pRequestedMode->MemMap].Start;
585:
586: //
587: // Store the new mode value.
588: //
589:
590: HwDeviceExtension->CurrentMode = pRequestedMode;
591: HwDeviceExtension->ModeIndex = Mode->RequestedMode;
592:
593: return NO_ERROR;
594:
595: } //end VgaSetMode()
596:
597:
598: VP_STATUS
599: VgaQueryAvailableModes(
600: PHW_DEVICE_EXTENSION HwDeviceExtension,
601: PVIDEO_MODE_INFORMATION ModeInformation,
602: ULONG ModeInformationSize,
603: PULONG OutputSize
604: )
605:
606: /*++
607:
608: Routine Description:
609:
610: This routine returns the list of all available available modes on the
611: card.
612:
613: Arguments:
614:
615: HwDeviceExtension - Pointer to the miniport driver's device extension.
616:
617: ModeInformation - Pointer to the output buffer supplied by the user.
618: This is where the list of all valid modes is stored.
619:
620: ModeInformationSize - Length of the output buffer supplied by the user.
621:
622: OutputSize - Pointer to a buffer in which to return the actual size of
623: the data in the buffer. If the buffer was not large enough, this
624: contains the minimum required buffer size.
625:
626: Return Value:
627:
628: ERROR_INSUFFICIENT_BUFFER if the output buffer was not large enough
629: for the data being returned.
630:
631: NO_ERROR if the operation completed successfully.
632:
633: --*/
634:
635: {
636: PVIDEO_MODE_INFORMATION videoModes = ModeInformation;
637: ULONG i;
638:
639: //
640: // Find out the size of the data to be put in the buffer and return
641: // that in the status information (whether or not the information is
642: // there). If the buffer passed in is not large enough return an
643: // appropriate error code.
644: //
645:
646: if (ModeInformationSize < (*OutputSize =
647: HwDeviceExtension->NumAvailableModes *
648: sizeof(VIDEO_MODE_INFORMATION)) ) {
649:
650: return ERROR_INSUFFICIENT_BUFFER;
651:
652: }
653:
654: //
655: // For each mode supported by the card, store the mode characteristics
656: // in the output buffer.
657: //
658:
659: for (i = 0; i < NumVideoModes; i++) {
660:
661: if (ModesVGA[i].ValidMode) {
662:
663: videoModes->Length = sizeof(VIDEO_MODE_INFORMATION);
664: videoModes->ModeIndex = i;
665: videoModes->VisScreenWidth = ModesVGA[i].hres;
666: videoModes->ScreenStride = ModesVGA[i].wbytes;
667: videoModes->VisScreenHeight = ModesVGA[i].vres;
668: videoModes->NumberOfPlanes = ModesVGA[i].numPlanes;
669: videoModes->BitsPerPlane = ModesVGA[i].bitsPerPlane;
670: videoModes->Frequency = ModesVGA[i].Frequency;
671: videoModes->XMillimeter = 330; // temporary hardcoded constant
672: videoModes->YMillimeter = 240; // temporary hardcoded constant
673: videoModes->NumberRedBits = 6;
674: videoModes->NumberGreenBits = 6;
675: videoModes->NumberBlueBits = 6;
676: videoModes->AttributeFlags = ModesVGA[i].fbType;
677: videoModes->AttributeFlags |= ModesVGA[i].Interlaced ?
678: VIDEO_MODE_INTERLACED : 0;
679:
680: videoModes->RedMask = 0;
681: videoModes->GreenMask = 0;
682: videoModes->BlueMask = 0;
683: videoModes->AttributeFlags |= VIDEO_MODE_PALETTE_DRIVEN |
684: VIDEO_MODE_MANAGED_PALETTE;
685:
686: videoModes++;
687:
688: }
689: }
690:
691: return NO_ERROR;
692:
693: } // end VgaGetAvailableModes()
694:
695: VP_STATUS
696: VgaQueryNumberOfAvailableModes(
697: PHW_DEVICE_EXTENSION HwDeviceExtension,
698: PVIDEO_NUM_MODES NumModes,
699: ULONG NumModesSize,
700: PULONG OutputSize
701: )
702:
703: /*++
704:
705: Routine Description:
706:
707: This routine returns the number of available modes for this particular
708: video card.
709:
710: Arguments:
711:
712: HwDeviceExtension - Pointer to the miniport driver's device extension.
713:
714: NumModes - Pointer to the output buffer supplied by the user. This is
715: where the number of modes is stored.
716:
717: NumModesSize - Length of the output buffer supplied by the user.
718:
719: OutputSize - Pointer to a buffer in which to return the actual size of
720: the data in the buffer.
721:
722: Return Value:
723:
724: ERROR_INSUFFICIENT_BUFFER if the output buffer was not large enough
725: for the data being returned.
726:
727: NO_ERROR if the operation completed successfully.
728:
729: --*/
730:
731: {
732: //
733: // Find out the size of the data to be put in the the buffer and return
734: // that in the status information (whether or not the information is
735: // there). If the buffer passed in is not large enough return an
736: // appropriate error code.
737: //
738:
739: if (NumModesSize < (*OutputSize = sizeof(VIDEO_NUM_MODES)) ) {
740:
741: return ERROR_INSUFFICIENT_BUFFER;
742:
743: }
744:
745: //
746: // Store the number of modes into the buffer.
747: //
748:
749: NumModes->NumModes = NumVideoModes;
750: NumModes->ModeInformationLength = sizeof(VIDEO_MODE_INFORMATION);
751:
752: return NO_ERROR;
753:
754: } // end VgaGetNumberOfAvailableModes()
755:
756: VP_STATUS
757: VgaQueryCurrentMode(
758: PHW_DEVICE_EXTENSION HwDeviceExtension,
759: PVIDEO_MODE_INFORMATION ModeInformation,
760: ULONG ModeInformationSize,
761: PULONG OutputSize
762: )
763:
764: /*++
765:
766: Routine Description:
767:
768: This routine returns a description of the current video mode.
769:
770: Arguments:
771:
772: HwDeviceExtension - Pointer to the miniport driver's device extension.
773:
774: ModeInformation - Pointer to the output buffer supplied by the user.
775: This is where the current mode information is stored.
776:
777: ModeInformationSize - Length of the output buffer supplied by the user.
778:
779: OutputSize - Pointer to a buffer in which to return the actual size of
780: the data in the buffer. If the buffer was not large enough, this
781: contains the minimum required buffer size.
782:
783: Return Value:
784:
785: ERROR_INSUFFICIENT_BUFFER if the output buffer was not large enough
786: for the data being returned.
787:
788: NO_ERROR if the operation completed successfully.
789:
790: --*/
791:
792: {
793: //
794: // Find out the size of the data to be put in the the buffer and return
795: // that in the status information (whether or not the information is
796: // there). If the buffer passed in is not large enough return an
797: // appropriate error code.
798: //
799:
800: if (ModeInformationSize < (*OutputSize = sizeof(VIDEO_MODE_INFORMATION))) {
801:
802: return ERROR_INSUFFICIENT_BUFFER;
803:
804: }
805:
806: //
807: // Store the characteristics of the current mode into the buffer.
808: //
809:
810: ModeInformation->Length = sizeof(VIDEO_MODE_INFORMATION);
811: ModeInformation->ModeIndex = HwDeviceExtension->ModeIndex;
812: ModeInformation->VisScreenWidth = HwDeviceExtension->CurrentMode->hres;
813: ModeInformation->ScreenStride = HwDeviceExtension->CurrentMode->wbytes;
814: ModeInformation->VisScreenHeight = HwDeviceExtension->CurrentMode->vres;
815: ModeInformation->NumberOfPlanes = HwDeviceExtension->CurrentMode->numPlanes;
816: ModeInformation->BitsPerPlane = HwDeviceExtension->CurrentMode->bitsPerPlane;
817: ModeInformation->Frequency = HwDeviceExtension->CurrentMode->Frequency;
818: ModeInformation->XMillimeter = 330; // temporary hardcoded constant
819: ModeInformation->YMillimeter = 240; // temporary hardcoded constant
820: ModeInformation->NumberRedBits = 6;
821: ModeInformation->NumberGreenBits = 6;
822: ModeInformation->NumberBlueBits = 6;
823: ModeInformation->RedMask = 0;
824: ModeInformation->GreenMask = 0;
825: ModeInformation->BlueMask = 0;
826: ModeInformation->AttributeFlags = HwDeviceExtension->CurrentMode->fbType |
827: VIDEO_MODE_PALETTE_DRIVEN | VIDEO_MODE_MANAGED_PALETTE;
828: ModeInformation->AttributeFlags |= HwDeviceExtension->CurrentMode->Interlaced ?
829: VIDEO_MODE_INTERLACED : 0;
830:
831: return NO_ERROR;
832:
833: } // end VgaQueryCurrentMode()
834:
835:
836: VOID
837: VgaZeroVideoMemory(
838: PHW_DEVICE_EXTENSION HwDeviceExtension
839: )
840: /*++
841:
842: Routine Description:
843:
844: This routine zeros the first 256K on the VGA.
845:
846: Arguments:
847:
848: HwDeviceExtension - Pointer to the miniport driver's device extension.
849:
850:
851: Return Value:
852:
853: None.
854:
855: --*/
856: {
857: UCHAR temp;
858:
859: //
860: // Map font buffer at A0000
861: //
862:
863: VgaInterpretCmdStream(HwDeviceExtension, EnableA000Data);
864:
865: //
866: // Enable all planes.
867: //
868: VideoPortWritePortUchar(HwDeviceExtension->IOAddress + SEQ_ADDRESS_PORT,
869: IND_MAP_MASK);
870:
871: temp = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
872: SEQ_DATA_PORT) | (UCHAR)0x0F;
873:
874: VideoPortWritePortUchar(HwDeviceExtension->IOAddress + SEQ_DATA_PORT,
875: temp);
876:
877: //
878: // Zero the memory.
879: //
880:
881: VideoPortZeroMemory(HwDeviceExtension->VideoMemoryAddress,
882: 0xFFFF);
883:
884: VgaInterpretCmdStream(HwDeviceExtension, DisableA000Color);
885:
886: }
887:
888:
889: VOID
890: VgaValidateModes(
891: PHW_DEVICE_EXTENSION HwDeviceExtension
892: )
893:
894: /*++
895:
896: Routine Description:
897:
898: Determines which modes are valid and which are not.
899:
900: Arguments:
901:
902: HwDeviceExtension - Pointer to the miniport driver's device extension.
903:
904: Return Value:
905:
906: None.
907:
908: --*/
909: {
910:
911: ULONG i;
912:
913: HwDeviceExtension->NumAvailableModes = 0;
914:
915: for (i = 0; i < NumVideoModes; i++) {
916:
917: if (HwDeviceExtension->AdapterMemorySize >=
918: ModesVGA[i].numPlanes * ModesVGA[i].sbytes) {
919:
920: ModesVGA[i].ValidMode = TRUE;
921: HwDeviceExtension->NumAvailableModes++;
922:
923: }
924:
925: //
926: // Older boards do not support 72HZ in 1024x768 modes.
927: // So disable those.
928: //
929:
930: if ( (HwDeviceExtension->BoardID < WD90C31) &&
931: (ModesVGA[i].hres == 1024) &&
932: (ModesVGA[i].vres == 768) &&
933: (ModesVGA[i].Frequency == 72) &&
934: (ModesVGA[i].ValidMode) ) {
935:
936: ModesVGA[i].ValidMode = FALSE;
937: HwDeviceExtension->NumAvailableModes--;
938:
939: }
940: }
941: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.