![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to screen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / displays / s3|
Return to screen.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / s3 |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: screen.c
3: *
4: * Initializes the GDIINFO and DEVINFO structures for DrvEnablePDEV.
5: *
6: * Copyright (c) 1992 Microsoft Corporation
7: \**************************************************************************/
8:
9: #include "driver.h"
10:
11: #define SYSTM_LOGFONT {16,7,0,0,700,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,VARIABLE_PITCH | FF_DONTCARE,L"System"}
12: #define HELVE_LOGFONT {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_STROKE_PRECIS,PROOF_QUALITY,VARIABLE_PITCH | FF_DONTCARE,L"MS Sans Serif"}
13: #define COURI_LOGFONT {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_STROKE_PRECIS,PROOF_QUALITY,FIXED_PITCH | FF_DONTCARE, L"Courier"}
14:
15: // This is the basic devinfo for a default driver. This is used as a base and customized based
16: // on information passed back from the miniport driver.
17:
18: const DEVINFO gDevInfoFrameBuffer = {
19: (GCAPS_OPAQUERECT | /* Graphics capabilities */
20: GCAPS_ALTERNATEFILL | GCAPS_WINDINGFILL |
21: GCAPS_TRAPPAINT | GCAPS_MONO_DITHER),
22: SYSTM_LOGFONT, /* Default font description */
23: HELVE_LOGFONT, /* ANSI variable font description */
24: COURI_LOGFONT, /* ANSI fixed font description */
25: 0, /* Count of device fonts */
26: 0, /* Preferred DIB format */
27: 8, /* Width of color dither */
28: 8, /* Height of color dither */
29: 0 /* Default palette to use for this device */
30: };
31:
32: PUCHAR gpucCsrBase = NULL;
33:
34: // Under a heavy loaded system it seems that IOCTL_VIDEO_SET_CURRENT_MODE failed,
35: // which caused the system to hang. This is where we record the last value
36: // from the miniport.
37:
38: BOOL gbLastReturnSetCurrentMode;
39:
40: /******************************Public*Routine******************************\
41: * bInitSURF
42: *
43: * Enables the surface. Maps the frame buffer into memory.
44: *
45: \**************************************************************************/
46:
47: BOOL bInitSURF(
48: PPDEV ppdev,
49: BOOL bFirst)
50: {
51: VIDEO_MEMORY VideoMemory;
52: VIDEO_MEMORY_INFORMATION VideoMemoryInfo;
53: DWORD ReturnedDataLength;
54: INT i;
55: BYTE byte;
56:
57: #if !defined(_X86_) && !defined(i386)
58: VIDEO_PUBLIC_ACCESS_RANGES VideoAccessRange;
59: #endif
60:
61:
62: DISPDBG((2, "S3.DLL! bInitSURF entry\n"));
63:
64: // Set the mode.
65:
66: gbLastReturnSetCurrentMode = DeviceIoControl(ppdev->hDriver,
67: IOCTL_VIDEO_SET_CURRENT_MODE,
68: &ppdev->ulMode, // input buffer
69: sizeof(DWORD),
70: NULL,
71: 0,
72: &ReturnedDataLength,
73: NULL);
74: if (gbLastReturnSetCurrentMode == FALSE)
75: {
76: DISPDBG((0, "S3.DLL!bInitSURF - Initialization error-Set mode"));
77: return (FALSE);
78: }
79:
80: if (bFirst)
81: {
82: #if !defined(_X86_) && !defined(i386)
83:
84: //
85: // Map io ports into virtual memory.
86: //
87:
88: VideoMemory.RequestedVirtualAddress = NULL;
89:
90: if (!DeviceIoControl(ppdev->hDriver,
91: IOCTL_VIDEO_QUERY_PUBLIC_ACCESS_RANGES,
92: NULL, // input buffer
93: 0,
94: (PVOID) &VideoAccessRange, // output buffer
95: sizeof (VideoAccessRange),
96: &ReturnedDataLength,
97: NULL)) {
98:
99: RIP("S3.DLL: Initialization error-Map IO port base");
100: return (FALSE);
101:
102: }
103:
104: gpucCsrBase = (PUCHAR)VideoAccessRange.VirtualAddress;
105:
106: #endif
107:
108: // Set all the register addresses.
109:
110: ppdev->cur_x = 0x86E8;
111: ppdev->cur_y = 0x82E8;
112:
113: ppdev->dest_x = 0x8EE8;
114: ppdev->dest_y = 0x8AE8;
115:
116: ppdev->axstp = 0x8AE8;
117: ppdev->diastp = 0x8EE8;
118:
119: ppdev->rect_width = 0x96E8;
120: ppdev->line_max = 0x96E8;
121:
122: ppdev->err_term = 0x92E8;
123:
124: ppdev->gp_stat = 0x9AE8;
125: ppdev->cmd = 0x9AE8;
126: ppdev->short_stroke_reg = 0x9EE8;
127:
128: ppdev->multifunc_cntl = 0xBEE8;
129:
130: ppdev->bkgd_color = 0xA2E8;
131: ppdev->frgd_color = 0xA6E8;
132:
133: ppdev->bkgd_mix = 0xB6E8;
134: ppdev->frgd_mix = 0xBAE8;
135:
136: ppdev->wrt_mask = 0xAAE8;
137: ppdev->rd_mask = 0xAEE8;
138:
139: ppdev->pixel_transfer = 0xE2E8;
140:
141: // Check if the I/O register need to be remapped.
142:
143: OUTPW (CRTC_INDEX, ((SYSCTL_UNLOCK << 8) | CR39));
144:
145: OUTP (CRTC_INDEX, 0x43);
146: if (INP(CRTC_DATA) & 0x10)
147: {
148: ppdev->cur_x ^= 0x3A0;
149: ppdev->cur_y ^= 0x3A0;
150: ppdev->dest_x ^= 0x3A0;
151: ppdev->dest_y ^= 0x3A0;
152: ppdev->axstp ^= 0x3A0;
153: ppdev->diastp ^= 0x3A0;
154: ppdev->rect_width ^= 0x3A0;
155: ppdev->line_max ^= 0x3A0;
156: ppdev->err_term ^= 0x3A0;
157: ppdev->gp_stat ^= 0x3A0;
158: ppdev->cmd ^= 0x3A0;
159: ppdev->short_stroke_reg ^= 0x3A0;
160: ppdev->multifunc_cntl ^= 0x3A0;
161: ppdev->bkgd_color ^= 0x3A0;
162: ppdev->frgd_color ^= 0x3A0;
163: ppdev->bkgd_mix ^= 0x3A0;
164: ppdev->frgd_mix ^= 0x3A0;
165: ppdev->wrt_mask ^= 0x3A0;
166: ppdev->rd_mask ^= 0x3A0;
167: ppdev->pixel_transfer ^= 0x3A0;
168: }
169:
170: // Get the linear memory address range.
171:
172: VideoMemory.RequestedVirtualAddress = NULL;
173:
174: if (!DeviceIoControl(ppdev->hDriver,
175: IOCTL_VIDEO_MAP_VIDEO_MEMORY,
176: (PVOID) &VideoMemory, // input buffer
177: sizeof (VIDEO_MEMORY),
178: (PVOID) &VideoMemoryInfo, // output buffer
179: sizeof (VideoMemoryInfo),
180: &ReturnedDataLength,
181: NULL))
182: {
183: DISPDBG((0, "S3.DLL!bInitSURF - Initialization error-Map buffer address"));
184: return (FALSE);
185: }
186:
187: // Record the Frame Buffer Linear Address.
188:
189: ppdev->pjScreen = (PBYTE) VideoMemoryInfo.FrameBufferBase;
190:
191: // Create a default Clip Object. This will be used when a NULL
192: // clip object is passed to us.
193:
194: ppdev->pcoDefault = EngCreateClip();
195:
196: ppdev->pcoDefault->iDComplexity = DC_RECT;
197: ppdev->pcoDefault->iMode = TC_RECTANGLES;
198:
199: ppdev->pcoDefault->rclBounds.left = 0;
200: ppdev->pcoDefault->rclBounds.top = 0;
201: ppdev->pcoDefault->rclBounds.right = ppdev->cxScreen;
202: ppdev->pcoDefault->rclBounds.bottom = ppdev->cyScreen;
203:
204: ppdev->pcoFullRam = EngCreateClip();
205:
206: ppdev->pcoFullRam->iDComplexity = DC_TRIVIAL;
207: ppdev->pcoFullRam->iMode = TC_RECTANGLES;
208:
209: ppdev->pcoFullRam->rclBounds.left = 0;
210: ppdev->pcoFullRam->rclBounds.top = 0;
211: ppdev->pcoFullRam->rclBounds.right = ppdev->cxMaxRam;
212: ppdev->pcoFullRam->rclBounds.bottom = ppdev->cyMaxRam;
213:
214: // Create a DDA object (now only used by trap enumeration)
215:
216: ppdev->pdda = EngCreateDDA();
217:
218: // Initialize the Unique Brush Counter,
219: // Allocate and Initialize the Brush cache manager arrays.
220: // Init the Expansion Cache Tags.
221:
222: ppdev->gBrushUnique = 1;
223:
224: ppdev->iMaxCachedColorBrushes = MAX_COLOR_PATTERNS;
225: ppdev->iNextColorBrushCacheSlot = 0;
226:
227: ppdev->pulColorBrushCacheEntries = (PULONG) LocalAlloc(LPTR, MAX_COLOR_PATTERNS * sizeof (ULONG));
228:
229: if (ppdev->pulColorBrushCacheEntries == NULL)
230: {
231: DISPDBG((0, "S3.DLL!bInitSURF - LocalAlloc for pulColorBrushCacheEntries failed\n"));
232: return (FALSE);
233: }
234:
235: ppdev->ulColorExpansionCacheTag = 0;
236:
237: ppdev->iMaxCachedMonoBrushes = MAX_MONO_PATTERNS;
238: ppdev->iNextMonoBrushCacheSlot = 0;
239:
240: ppdev->pulMonoBrushCacheEntries = (PULONG) LocalAlloc(LPTR, MAX_MONO_PATTERNS * sizeof (ULONG));
241:
242: if (ppdev->pulMonoBrushCacheEntries == NULL)
243: {
244: DISPDBG((0, "S3.DLL!bInitSURF - LocalAlloc for pulMonoBrushCacheEntries failed\n"));
245: return (FALSE);
246: }
247:
248: for (i = 0; i < 8; i++)
249: {
250: ppdev->aulMonoExpansionCacheTag[i] = 0;
251: }
252:
253: ppdev->iNextMonoBrushExpansionSlot = 0;
254:
255: // Init the cache tags for the Source bitmap cache.
256:
257: ppdev->hsurfCachedBitmap = NULL;
258: ppdev->iUniqCachedBitmap = (ULONG) -1;
259:
260: // Init the Save Screen Bits structures.
261:
262: ppdev->iUniqeSaveScreenBits = 1;
263: ppdev->SavedScreenBitsHeader.pssbLink = NULL;
264: ppdev->SavedScreenBitsHeader.iUniq = (ULONG) -1;
265:
266: // Get the chip ID and set the New Bank Control bool.
267:
268: OUTPW(0x3d4, 0x4838); // unlocke S3 regs
269: OUTP(0x3d4, 0x30); // crtc index for S# ID reg
270: byte = INP(0x3d5); // Get the ID
271: OUTPW(0x3d4, 0x0038); // Lock the S3 regs
272:
273: ppdev->s3ChipID = byte;
274:
275: if (ppdev->cxScreen == 1280)
276: ppdev->bBt485Dac = TRUE;
277: else
278: ppdev->bBt485Dac = FALSE;
279:
280: // Pickup the initial value for the Pointer Control Register.
281: // This is requried for the 928,801/805 and benign on the 911/924.
282:
283: OUTP(CRTC_INDEX, HGC_MODE);
284: ppdev->HgcMode = ((INP(CRTC_DATA) & ~0x11) << 8) | HGC_MODE;
285:
286: switch(byte)
287: {
288: case 0x90: // 801/805 rev 0
289: case 0x91: // 801/805 rev 1
290: case 0x92: // 801/805 rev 2
291: case 0x93: // 801/805 rev 3
292:
293: case 0xA0: // 928 rev 0
294: case 0xA1: // 928 rev 1
295: case 0xA2: // 928 rev 2
296: case 0xA3: // 928 rev 3
297: ppdev->bNewBankControl = TRUE;
298:
299: // Pick up the initial values for the System Control and Linear Address
300: // Windows Control register.
301:
302: OUTPW (CRTC_INDEX, ((SYSCTL_UNLOCK << 8) | CR39));
303:
304: OUTP(CRTC_INDEX, SYS_CNFG);
305: ppdev->SysCnfg = ((INP(CRTC_DATA) << 8) | SYS_CNFG) & ~0x0900;
306:
307: OUTP(CRTC_INDEX, LAW_CTL);
308: ppdev->LawCtl = ((INP(CRTC_DATA) << 8) | LAW_CTL) & ~0x1000;
309:
310: OUTP(CRTC_INDEX, EX_SCTL_2);
311: ppdev->ExtSysCtl2 = (INP(CRTC_DATA) & ~0x0C);
312:
313: if (ppdev->bBt485Dac == TRUE)
314: {
315: // Make a copy of the Extened DAC control register
316:
317: OUTP(CRTC_INDEX, EX_DAC_CT);
318: ppdev->ExtDacCtl = (((INP(CRTC_DATA) << 8) | EX_DAC_CT) & ~0x0300) ;
319:
320: // Get a copy of the Bt486 command register 0
321:
322: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0100));
323: ppdev->Bt485CmdReg0 = INP (BT485_ADDR_CMD_REG0);
324:
325: // Get a copy of the Bt486 command register 1
326:
327: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0200));
328: ppdev->Bt485CmdReg1 = INP (BT485_ADDR_CMD_REG1);
329:
330: // Get a copy of the Bt486 command register 2
331: // And mask off the Cursor control bits.
332:
333: ppdev->Bt485CmdReg2 = INP (BT485_ADDR_CMD_REG2) & BT485_CURSOR_DISABLE;
334:
335: // Disable the cursor
336:
337: OUTP (BT485_ADDR_CMD_REG2, ppdev->Bt485CmdReg2);
338:
339: // To get the Bt485 command register 3 we have to go through
340: // following indirection "dance".
341:
342: // First set the Command Reg3 access bit in Command Reg0
343:
344: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0100));
345: OUTP (BT485_ADDR_CMD_REG0, ppdev->Bt485CmdReg0 | BT485_CMD_REG_3_ACCESS);
346:
347: // Now set the index to 1
348:
349: OUTPW (CRTC_INDEX, ppdev->ExtDacCtl);
350: OUTP (0x3c8, 0x01);
351:
352: // Now access command register 3
353: // and save the value away
354:
355: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0200));
356: ppdev->Bt485CmdReg3 = INP(BT485_ADDR_CMD_REG3);
357:
358: // Set Command register 3 for a 64 X 64 cursor.
359:
360: ppdev->Bt485CmdReg3 |= BT485_64X64_CURSOR;
361: OUTP (BT485_ADDR_CMD_REG3, ppdev->Bt485CmdReg3);
362:
363: // Disable access to command reg 3
364:
365: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0100));
366: OUTP (BT485_ADDR_CMD_REG0, ppdev->Bt485CmdReg0);
367:
368: // Set the color 1 and color 2 for the cursor.
369: // Select Address register; cursor/overscan color write on the Bt485.
370:
371: OUTPW (CRTC_INDEX, (ppdev->ExtDacCtl | 0x0100));
372: OUTP (BT485_ADDR_CUR_COLOR_WRITE, BT485_CURSOR_COLOR_1);
373:
374: // Output the RGB for Cursor color 1
375:
376: OUTP (BT485_CUR_COLOR_DATA, 0x00);
377: OUTP (BT485_CUR_COLOR_DATA, 0x00);
378: OUTP (BT485_CUR_COLOR_DATA, 0x00);
379:
380: // Output the RGB for Cursor color 2
381:
382: OUTP (BT485_CUR_COLOR_DATA, 0xff);
383: OUTP (BT485_CUR_COLOR_DATA, 0xff);
384: OUTP (BT485_CUR_COLOR_DATA, 0xff);
385:
386: // reset the DAC addr
387:
388: OUTPW (CRTC_INDEX, ppdev->ExtDacCtl);
389: }
390:
391: break;
392:
393: case 0x81: // 911
394: case 0x82: // 924
395: default:
396: ppdev->bNewBankControl = FALSE;
397: break;
398: }
399: }
400:
401: // Initialize the shadow copies of the S3 registers to an
402: // invalid state. This also needs to be done when we return from a
403: // screen session.
404:
405: ppdev->ForegroundMix =
406: ppdev->BackgroundMix =
407: ppdev->ForegroundColor =
408: ppdev->BackgroundColor =
409: ppdev->WriteMask =
410: ppdev->ReadMask = (WORD) -1;
411:
412: // Reset the clipping registers.
413:
414: vResetS3Clipping(ppdev);
415:
416: // Unlock the registers used by the cursor
417:
418: OUTPW (CRTC_INDEX, ((SYSCTL_UNLOCK << 8) | CR39));
419:
420: return(TRUE);
421: }
422:
423: /******************************Public*Routine******************************\
424: * vDisableSURF
425: *
426: * Disable the surface. Un-Maps the frame in memory.
427: *
428: \**************************************************************************/
429:
430: VOID vDisableSURF(PPDEV ppdev)
431: {
432: DWORD returnedDataLength;
433: VIDEO_MEMORY videoMemory;
434:
435: videoMemory.RequestedVirtualAddress = (PVOID) ppdev->pjScreen;
436:
437: if (!DeviceIoControl(ppdev->hDriver,
438: IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,
439: &videoMemory,
440: sizeof(VIDEO_MEMORY),
441: NULL,
442: 0,
443: &returnedDataLength,
444: NULL))
445: {
446: DISPDBG((0, "DISP vDisableSURF failed IOCTL_VIDEO_UNMAP\n"));
447: }
448:
449: #if !defined(_X86_) && !defined(i386)
450:
451:
452: // NOTE NOTE NOTE
453: //
454: // WE NEED TO UNMAP THE CSRS HERE!
455:
456: #endif
457:
458: }
459:
460: /******************************Public*Routine******************************\
461: * bInitPDEV
462: *
463: * Determine the mode we should be in based on the DEVMODE passed in.
464: * Query mini-port to get information needed to fill in the DevInfo and the
465: * GdiInfo .
466: *
467: \**************************************************************************/
468:
469: BOOL bInitPDEV(
470: PPDEV ppdev,
471: DEVMODEW *pDevMode)
472: {
473:
474:
475: ULONG cModes;
476: PVIDEO_MODE_INFORMATION pVideoBuffer, pVideoModeSelected, pVideoTemp;
477: BOOL bSelectDefault;
478: GDIINFO *pGdiInfo;
479: VIDEO_MODE_INFORMATION VideoModeInformation;
480: ULONG cbModeSize;
481:
482:
483: DISPDBG((2,"S3.DLL:!bInitPDEV - Entry\n"));
484:
485: pGdiInfo = ppdev->pGdiInfo;
486:
487: //
488: // calls the miniport to get mode information.
489: //
490:
491: cModes = getAvailableModes(ppdev->hDriver, &pVideoBuffer, &cbModeSize);
492:
493: if (cModes == 0)
494: {
495: return(FALSE);
496: }
497:
498: //
499: // Determine if we are looking for a default mode.
500: //
501:
502: if ( ((pDevMode->dmPelsWidth) ||
503: (pDevMode->dmPelsHeight) ||
504: (pDevMode->dmBitsPerPel) ||
505: (pDevMode->dmDisplayFlags) ||
506: (pDevMode->dmDisplayFrequency)) == 0)
507: {
508: bSelectDefault = TRUE;
509: }
510: else
511: {
512: bSelectDefault = FALSE;
513: }
514:
515: //
516: // Now see if the requested mode has a match in that table.
517: //
518:
519: pVideoModeSelected = NULL;
520: pVideoTemp = pVideoBuffer;
521:
522: while (cModes--)
523: {
524: if (pVideoTemp->Length != 0)
525: {
526: if (bSelectDefault ||
527: ((pVideoTemp->VisScreenWidth == pDevMode->dmPelsWidth) &&
528: (pVideoTemp->VisScreenHeight == pDevMode->dmPelsHeight) &&
529: (pVideoTemp->BitsPerPlane *
530: pVideoTemp->NumberOfPlanes == pDevMode->dmBitsPerPel)) &&
531: (pVideoTemp->Frequency == pDevMode->dmDisplayFrequency))
532: {
533: pVideoModeSelected = pVideoTemp;
534: DISPDBG((3, "S3: Found a match\n"));
535: break;
536: }
537: }
538:
539: pVideoTemp = (PVIDEO_MODE_INFORMATION)
540: (((PUCHAR)pVideoTemp) + cbModeSize);
541:
542: }
543:
544: //
545: // If no mode has been found, return an error
546: //
547:
548: if (pVideoModeSelected == NULL)
549: {
550: return(FALSE);
551: }
552:
553:
554: // We have chosen the one we want. Save it in a stack buffer and
555: // get rid of allocated memory before we forget to free it.
556:
557: VideoModeInformation = *pVideoModeSelected;
558: LocalFree(pVideoBuffer);
559:
560: // Set up screen information from the mini-port
561:
562: ppdev->ulMode = VideoModeInformation.ModeIndex;
563: ppdev->cxScreen = VideoModeInformation.VisScreenWidth;
564: ppdev->cyScreen = VideoModeInformation.VisScreenHeight;
565:
566: ppdev->cxMaxRam = VideoModeInformation.VideoMemoryBitmapWidth;
567: ppdev->cyMaxRam = VideoModeInformation.VideoMemoryBitmapHeight;
568:
569: ppdev->ulBitCount = VideoModeInformation.BitsPerPlane *
570: VideoModeInformation.NumberOfPlanes;
571: ppdev->lDeltaScreen = VideoModeInformation.ScreenStride;
572:
573: ppdev->flRed = VideoModeInformation.RedMask;
574: ppdev->flGreen = VideoModeInformation.GreenMask;
575: ppdev->flBlue = VideoModeInformation.BlueMask;
576:
577: // Fill in the GDIINFO data structure with the information
578: // returned from the kernel driver.
579:
580: pGdiInfo->ulVersion = 0x1000; // Our driver is version 1.000
581: pGdiInfo->ulTechnology = DT_RASDISPLAY;
582: pGdiInfo->ulHorzSize = VideoModeInformation.XMillimeter;
583: pGdiInfo->ulVertSize = VideoModeInformation.YMillimeter;
584:
585: pGdiInfo->ulHorzRes = ppdev->cxScreen;
586: pGdiInfo->ulVertRes = ppdev->cyScreen;
587: pGdiInfo->cBitsPixel = VideoModeInformation.BitsPerPlane;
588: pGdiInfo->cPlanes = VideoModeInformation.NumberOfPlanes;
589:
590: // The following block of code is left in place to make it easy
591: // when we go to a 16/24/32 bit per pixel bitmap.
592:
593: if (ppdev->ulBitCount == 8)
594: {
595: // It is Palette Managed.
596:
597: pGdiInfo->ulNumColors = 20;
598: pGdiInfo->ulNumPalReg = 1 << ppdev->ulBitCount;
599:
600: pGdiInfo->flRaster = 0; // DDI reserved field
601: }
602: else
603: {
604: pGdiInfo->ulNumColors = 1 << ppdev->ulBitCount;
605: pGdiInfo->ulNumPalReg = 0;
606:
607: pGdiInfo->flRaster = 0; // DDI reserved field
608: }
609:
610: pGdiInfo->ulLogPixelsX = 96;
611: pGdiInfo->ulLogPixelsY = 96;
612:
613: pGdiInfo->flTextCaps = TC_RA_ABLE;
614:
615: pGdiInfo->ulDACRed = VideoModeInformation.NumberRedBits;
616: pGdiInfo->ulDACGreen = VideoModeInformation.NumberGreenBits;
617: pGdiInfo->ulDACBlue = VideoModeInformation.NumberBlueBits;
618:
619: pGdiInfo->xStyleStep = 1; // A style unit is 3 pels
620: pGdiInfo->yStyleStep = 1;
621: pGdiInfo->denStyleStep = 3;
622:
623: pGdiInfo->ulAspectX = 0x24; // One-to-one aspect ratio
624: pGdiInfo->ulAspectY = 0x24;
625: pGdiInfo->ulAspectXY = 0x33;
626:
627: pGdiInfo->ptlPhysOffset.x = 0;
628: pGdiInfo->ptlPhysOffset.y = 0;
629: pGdiInfo->szlPhysSize.cx = 0;
630: pGdiInfo->szlPhysSize.cy = 0;
631:
632: // RGB and CMY color info.
633:
634: pGdiInfo->ciDevice.Red.x = 6700;
635: pGdiInfo->ciDevice.Red.y = 3300;
636: pGdiInfo->ciDevice.Red.Y = 0;
637:
638: pGdiInfo->ciDevice.Green.x = 2100;
639: pGdiInfo->ciDevice.Green.y = 7100;
640: pGdiInfo->ciDevice.Green.Y = 0;
641:
642: pGdiInfo->ciDevice.Blue.x = 1400;
643: pGdiInfo->ciDevice.Blue.y = 800;
644: pGdiInfo->ciDevice.Blue.Y = 0;
645:
646: pGdiInfo->ciDevice.Cyan.x = 1750;
647: pGdiInfo->ciDevice.Cyan.y = 3950;
648: pGdiInfo->ciDevice.Cyan.Y = 0;
649:
650: pGdiInfo->ciDevice.Magenta.x = 4050;
651: pGdiInfo->ciDevice.Magenta.y = 2050;
652: pGdiInfo->ciDevice.Magenta.Y = 0;
653:
654: pGdiInfo->ciDevice.Yellow.x = 4400;
655: pGdiInfo->ciDevice.Yellow.y = 5200;
656: pGdiInfo->ciDevice.Yellow.Y = 0;
657:
658: pGdiInfo->ciDevice.AlignmentWhite.x = 3127;
659: pGdiInfo->ciDevice.AlignmentWhite.y = 3290;
660: pGdiInfo->ciDevice.AlignmentWhite.Y = 0;
661:
662: // Color Gamma adjustment values.
663:
664: pGdiInfo->ciDevice.RedGamma = 20000;
665: pGdiInfo->ciDevice.GreenGamma = 20000;
666: pGdiInfo->ciDevice.BlueGamma = 20000;
667:
668: // No dye correction for raster displays.
669:
670: pGdiInfo->ciDevice.MagentaInCyanDye = 0;
671: pGdiInfo->ciDevice.YellowInCyanDye = 0;
672: pGdiInfo->ciDevice.CyanInMagentaDye = 0;
673: pGdiInfo->ciDevice.YellowInMagentaDye = 0;
674: pGdiInfo->ciDevice.CyanInYellowDye = 0;
675: pGdiInfo->ciDevice.MagentaInYellowDye = 0;
676:
677: pGdiInfo->ulDevicePelsDPI = 0; // For printers only
678: pGdiInfo->ulPrimaryOrder = PRIMARY_ORDER_CBA;
679: pGdiInfo->ulHTPatternSize = HT_PATSIZE_4x4_M;
680: pGdiInfo->ulHTOutputFormat = HT_FORMAT_8BPP;
681: pGdiInfo->flHTFlags = HT_FLAG_ADDITIVE_PRIMS;
682:
683: // Fill in the devinfo structure
684:
685: *(ppdev->pDevInfo) = gDevInfoFrameBuffer;
686:
687: if (ppdev->ulBitCount == 8)
688: {
689: ppdev->pDevInfo->flGraphicsCaps |= (GCAPS_PALMANAGED |
690: GCAPS_COLOR_DITHER);
691: ppdev->pDevInfo->iDitherFormat = BMF_8BPP;
692: }
693: else if (ppdev->ulBitCount == 16)
694: {
695: ppdev->pDevInfo->iDitherFormat = BMF_16BPP;
696: }
697: else
698: {
699: ppdev->pDevInfo->iDitherFormat = BMF_32BPP;
700: }
701:
702: return(TRUE);
703: }
704:
705:
706: /******************************Public*Routine******************************\
707: * getAvailableModes
708: *
709: * Calls the miniport to get the list of modes supported by the kernel driver,
710: * and returns the list of modes supported by the diplay driver among those
711: *
712: * returns the number of entries in the videomode buffer.
713: * 0 means no modes are supported by the miniport or that an error occured.
714: *
715: * NOTE: the buffer must be freed up by the caller.
716: *
717: \**************************************************************************/
718: DWORD getAvailableModes(
719: HANDLE hDriver,
720: PVIDEO_MODE_INFORMATION *modeInformation,
721: DWORD *cbModeSize)
722: {
723:
724: ULONG ulTemp;
725: VIDEO_NUM_MODES modes;
726: PVIDEO_MODE_INFORMATION pVideoTemp;
727:
728: //
729: // Get the number of modes supported by the mini-port
730: //
731:
732: if (!DeviceIoControl(hDriver,
733: IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES,
734: NULL,
735: 0,
736: &modes,
737: sizeof(VIDEO_NUM_MODES),
738: &ulTemp,
739: NULL))
740: {
741: DISPDBG((0, "s3.dll getAvailableModes failed VIDEO_QUERY_NUM_AVAIL_MODES\n"));
742: return(0);
743: }
744:
745: *cbModeSize = modes.ModeInformationLength;
746:
747: //
748: // Allocate the buffer for the mini-port to write the modes in.
749: //
750:
751: *modeInformation = (PVIDEO_MODE_INFORMATION)
752: LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT,
753: modes.NumModes *
754: modes.ModeInformationLength);
755:
756: if (*modeInformation == (PVIDEO_MODE_INFORMATION) NULL)
757: {
758: DISPDBG((0, "S3.dll: getAvailableModes failed LocalAlloc\n"));
759: return 0;
760: }
761:
762: //
763: // Ask the mini-port to fill in the available modes.
764: //
765:
766: if (!DeviceIoControl(hDriver,
767: IOCTL_VIDEO_QUERY_AVAIL_MODES,
768: NULL,
769: 0,
770: *modeInformation,
771: modes.NumModes * modes.ModeInformationLength,
772: &ulTemp,
773: NULL))
774: {
775:
776: DISPDBG((0, "S3.dll: getAvailableModes failed VIDEO_QUERY_AVAIL_MODES\n"));
777:
778: LocalFree(*modeInformation);
779: *modeInformation = (PVIDEO_MODE_INFORMATION) NULL;
780:
781: return(0);
782: }
783:
784: //
785: // Now see which of these modes are supported by the display driver.
786: // As an internal mechanism, set the length to 0 for the modes we
787: // DO NOT support.
788: //
789:
790: ulTemp = modes.NumModes;
791: pVideoTemp = *modeInformation;
792:
793: //
794: // Mode is rejected if it is not one plane, or not graphics, or is not
795: // one of 8, 16 or 32 bits per pel.
796: //
797:
798: while (ulTemp--)
799: {
800: if ((pVideoTemp->NumberOfPlanes != 1 ) ||
801: !(pVideoTemp->AttributeFlags & VIDEO_MODE_GRAPHICS) ||
802: ((pVideoTemp->BitsPerPlane != 8) &&
803: (pVideoTemp->BitsPerPlane != 16) &&
804: (pVideoTemp->BitsPerPlane != 32)))
805: {
806: pVideoTemp->Length = 0;
807: }
808:
809: pVideoTemp = (PVIDEO_MODE_INFORMATION)
810: (((PUCHAR)pVideoTemp) + modes.ModeInformationLength);
811: }
812:
813: return modes.NumModes;
814: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.