ReactOS  0.4.14-dev-49-gfb4591c
vbemodes.c
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS VGA Miniport Driver
3  * LICENSE: BSD - See COPYING.ARM in the top level directory
4  * FILE: win32ss/drivers/miniport/vga_new/vbemodes.c
5  * PURPOSE: Mode Initialization and Mode Set for VBE-compatible cards
6  * PROGRAMMERS: ReactOS Portable Systems Group
7  */
8 
9 /* INCLUDES *******************************************************************/
10 
11 #include "vga.h"
12 
13 /* FUNCTIONS ******************************************************************/
14 
15 ULONG
16 NTAPI
18 {
19  ULONG SquaredResult = Value;
20  if ((Value - 1) & Value) for (SquaredResult = 1; (SquaredResult < Value) && (SquaredResult); SquaredResult *= 2);
21  return SquaredResult;
22 }
23 
24 ULONG
25 NTAPI
27 {
28  ULONG SquaredResult = Value;
29  if ((Value - 1) & Value) for (SquaredResult = 1; (SquaredResult < Value) && (SquaredResult); SquaredResult *= 2);
30  return SquaredResult;
31 }
32 
33 ULONG
34 NTAPI
37 {
38  ULONG Length = 4 * 1024;
39  USHORT TrampolineMemorySegment, TrampolineMemoryOffset;
40  PVOID Context;
41  INT10_BIOS_ARGUMENTS BiosArguments;
42  PVBE_MODE_INFO VbeModeInfo;
45 
46  /* Need linear and INT10 interface */
47  if (!(VgaMode->fbType & VIDEO_MODE_BANKED)) return 0;
48  if (VgaExtension->Int10Interface.Size) return 0;
49 
50  /* Allocate scratch area and context */
51  VbeModeInfo = VideoPortAllocatePool(VgaExtension, 1, sizeof(VBE_MODE_INFO), ' agV');
52  if (!VbeModeInfo) return 0;
53  Context = VgaExtension->Int10Interface.Context;
54  Status = VgaExtension->Int10Interface.Int10AllocateBuffer(Context,
55  &TrampolineMemorySegment,
56  &TrampolineMemoryOffset,
57  &Length);
58  if (Status != NO_ERROR) return 0;
59 
60  /* Ask VBE BIOS for mode info */
61  VideoPortZeroMemory(&BiosArguments, sizeof(BiosArguments));
62  BiosArguments.Ecx = HIWORD(VgaMode->Mode);
63  BiosArguments.Edi = TrampolineMemorySegment;
64  BiosArguments.SegEs = TrampolineMemoryOffset;
65  BiosArguments.Eax = VBE_GET_MODE_INFORMATION;
66  Status = VgaExtension->Int10Interface.Int10CallBios(Context, &BiosArguments);
67  if (Status != NO_ERROR) return 0;
68  if (VBE_GETRETURNCODE(BiosArguments.Eax) != VBE_SUCCESS)
69  return 0;
70  Status = VgaExtension->Int10Interface.Int10ReadMemory(Context,
71  TrampolineMemorySegment,
72  TrampolineMemoryOffset,
73  VbeModeInfo,
74  sizeof(VBE_MODE_INFO));
75  if (Status != NO_ERROR) return 0;
76 
77  /* Return phys address and cleanup */
78  BaseAddress = VbeModeInfo->PhysBasePtr;
79  VgaExtension->Int10Interface.Int10FreeBuffer(Context,
80  TrampolineMemorySegment,
81  TrampolineMemoryOffset);
82  VideoPortFreePool(VgaExtension, VbeModeInfo);
83  return BaseAddress;
84 }
85 
87 NTAPI
88 VbeSetMode(IN PHW_DEVICE_EXTENSION VgaDeviceExtension,
90  OUT PULONG PhysPtrChange)
91 {
93  VIDEO_X86_BIOS_ARGUMENTS BiosArguments;
94  ULONG ModeIndex;
96 
97  VideoPortZeroMemory(&BiosArguments, sizeof(BiosArguments));
98  ModeIndex = VgaMode->Mode;
99  BiosArguments.Eax = VBE_SET_VBE_MODE;
100  BiosArguments.Ebx = HIWORD(ModeIndex);
101  VideoDebugPrint((0, "Switching to %lx %lx\n", BiosArguments.Eax, BiosArguments.Ebx));
102  Status = VideoPortInt10(VgaDeviceExtension, &BiosArguments);
103  if (Status != NO_ERROR) return Status;
104  if(VBE_GETRETURNCODE(BiosArguments.Eax) != VBE_SUCCESS)
105  {
106  VideoDebugPrint((0, "Changing VBE mode failed, Eax %lx", BiosArguments.Eax));
108  }
109 
110  /* Check for VESA mode */
111  if (ModeIndex >> 16)
112  {
113  /* Mode set fail */
114  if (VBE_GETRETURNCODE(BiosArguments.Eax) != VBE_SUCCESS)
116 
117  /* Check current mode is desired mode */
118  VideoPortZeroMemory(&BiosArguments, sizeof(BiosArguments));
119  BiosArguments.Eax = VBE_GET_CURRENT_VBE_MODE;
120  Status = VideoPortInt10(VgaDeviceExtension, &BiosArguments);
121  if ((Status == NO_ERROR) &&
122  (VBE_GETRETURNCODE(BiosArguments.Eax) == VBE_SUCCESS) &&
123  ((BiosArguments.Ebx ^ (ModeIndex >> 16)) & VBE_MODE_BITS))
124  {
126  }
127 
128  /* Set logical scanline width if different from physical */
129  if (VgaMode->LogicalWidth != VgaMode->hres)
130  {
131  /* Check setting works after being set */
132  VideoPortZeroMemory(&BiosArguments, sizeof(BiosArguments));
134  BiosArguments.Ecx = VgaMode->LogicalWidth;
135  BiosArguments.Ebx = 0;
136  Status = VideoPortInt10(VgaDeviceExtension, &BiosArguments);
137  if ((Status != NO_ERROR) ||
138  (VBE_GETRETURNCODE(BiosArguments.Eax) != VBE_SUCCESS) ||
139  (BiosArguments.Ecx != VgaMode->LogicalWidth))
140  {
142  }
143  }
144  }
145 
146  /* Get VRAM address to update changes */
147  BaseAddress = VbeGetVideoMemoryBaseAddress(VgaDeviceExtension, VgaMode);
148  if ((BaseAddress) && (VgaMode->PhysBase != BaseAddress))
149  {
150  *PhysPtrChange = TRUE;
151  VgaMode->PhysBase = BaseAddress;
152  }
153 
154  return NO_ERROR;
155 }
156 
157 VOID
158 NTAPI
160 {
161  ULONG ModeCount = 0;
162  ULONG Length = 4 * 1024;
163  ULONG TotalMemory;
165  INT10_BIOS_ARGUMENTS BiosArguments;
166  PVBE_INFO VbeInfo;
167  PVBE_MODE_INFO VbeModeInfo;
168  PVOID Context;
169  USHORT TrampolineMemorySegment;
170  USHORT TrampolineMemoryOffset;
171  ULONG VbeVersion;
172  ULONG NewModes = 0;
173  BOOLEAN FourBppModeFound = FALSE;
174  USHORT ModeResult;
175  USHORT Mode;
176  PUSHORT ThisMode;
177  BOOLEAN LinearAddressing;
178  ULONG Size, ScreenSize;
181  ULONG ScreenStride;
183 
184  /* Enable only default vga modes if no vesa */
186  if (VideoPortIsNoVesa())
187  {
188  VgaExtension->Int10Interface.Size = 0;
189  VgaExtension->Int10Interface.Version = 0;
190  return;
191  }
192 
193  /* Query INT10 interface */
194  VgaExtension->Int10Interface.Version = VIDEO_PORT_INT10_INTERFACE_VERSION_1;
195  VgaExtension->Int10Interface.Size = sizeof(VIDEO_PORT_INT10_INTERFACE);
196  if (VideoPortQueryServices(VgaExtension,
198  (PINTERFACE)&VgaExtension->Int10Interface))
199  {
200  VgaExtension->Int10Interface.Size = 0;
201  VgaExtension->Int10Interface.Version = 0;
202  }
203 
204  /* Add ref */
205  VideoDebugPrint((0, "have int10 iface\n"));
206  VgaExtension->Int10Interface.InterfaceReference(VgaExtension->Int10Interface.Context);
207  Context = VgaExtension->Int10Interface.Context;
208 
209  /* Allocate scratch area and context */
210  Status = VgaExtension->Int10Interface.Int10AllocateBuffer(Context,
211  &TrampolineMemorySegment,
212  &TrampolineMemoryOffset,
213  &Length);
214  if (Status != NO_ERROR) return;
215  VbeInfo = VideoPortAllocatePool(VgaExtension, 1, sizeof(VBE_INFO), ' agV');
216  if (!VbeInfo) return;
217 
218  VbeModeInfo = &VbeInfo->Modes;
219 
220  /* Init VBE data and write to card buffer */
221  VideoDebugPrint((0, "have int10 data\n"));
222  VbeInfo->ModeArray[128] = 0xFFFF;
223  VbeInfo->Info.Signature = VBE2_MAGIC;
224  Status = VgaExtension->Int10Interface.Int10WriteMemory(Context,
225  TrampolineMemorySegment,
226  TrampolineMemoryOffset,
227  &VbeInfo->Info.Signature,
228  4);
229  if (Status != NO_ERROR) return;
230 
231  /* Get controller info */
232  VideoPortZeroMemory(&BiosArguments, sizeof(BiosArguments));
233  BiosArguments.Edi = TrampolineMemoryOffset;
234  BiosArguments.SegEs = TrampolineMemorySegment;
235  BiosArguments.Eax = VBE_GET_CONTROLLER_INFORMATION;
236  Status = VgaExtension->Int10Interface.Int10CallBios(Context, &BiosArguments);
237  if (Status != NO_ERROR) return;
238  if(VBE_GETRETURNCODE(BiosArguments.Eax) != VBE_SUCCESS)
239  {
240  VideoDebugPrint((0, "BiosArguments.Eax %lx\n", BiosArguments.Eax));
241  return;
242  }
243  Status = VgaExtension->Int10Interface.Int10ReadMemory(Context,
244  TrampolineMemorySegment,
245  TrampolineMemoryOffset,
246  VbeInfo,
247  512);
248  if (Status != NO_ERROR) return;
249 
250  /* Check correct VBE BIOS */
251  VideoDebugPrint((0, "have vbe data\n"));
252  TotalMemory = VbeInfo->Info.TotalMemory << 16;
253  VbeVersion = VbeInfo->Info.Version;
254  VideoDebugPrint((0, "vbe version %lx memory %lx\n", VbeVersion, TotalMemory));
255  if (!ValidateVbeInfo(VgaExtension, VbeInfo)) return;
256 
257  /* Read modes */
258  VideoDebugPrint((0, "read modes from %p\n", VbeInfo->Info.VideoModePtr));
259  Status = VgaExtension->Int10Interface.Int10ReadMemory(Context,
260  HIWORD(VbeInfo->Info.VideoModePtr),
261  LOWORD(VbeInfo->Info.VideoModePtr),
262  VbeInfo->ModeArray,
263  128 * sizeof(USHORT));
264  if (Status != NO_ERROR) return;
265  VideoDebugPrint((0, "Read modes at: %p\n", VbeInfo->ModeArray));
266 
267  /* Count modes, check for new 4bpp SVGA modes */
268  ThisMode = VbeInfo->ModeArray;
269  ModeResult = VbeInfo->ModeArray[0];
270  while (ModeResult != 0xFFFF)
271  {
272  Mode = ModeResult & 0x1FF;
273  VideoDebugPrint((0, "Mode found: %lx\n", Mode));
274  if ((Mode == 0x102) || (Mode == 0x6A)) FourBppModeFound = TRUE;
275  ModeResult = *++ThisMode;
276  NewModes++;
277  }
278 
279  /* Remove the built-in mode if not supported by card and check max modes */
280  if (!FourBppModeFound) --NumVideoModes;
281  if ((NewModes >= 128) && (NumVideoModes > 8)) goto Cleanup;
282 
283  /* Switch to new SVGA mode list, copy VGA modes */
284  VgaModeList = VideoPortAllocatePool(VgaExtension, 1, (NewModes + NumVideoModes) * sizeof(VIDEOMODE), ' agV');
285  if (!VgaModeList) goto Cleanup;
287 
288  /* Apply fixup for Intel Brookdale */
290  {
291  VideoDebugPrint((0, "Intel Brookdale-G Video BIOS Not Support!\n"));
292  while (TRUE);
293  }
294 
295  /* Scan SVGA modes */
296  VideoDebugPrint((0, "Static modes: %d\n", NumVideoModes));
298  ThisMode = VbeInfo->ModeArray;
299  VideoDebugPrint((0, "new modes: %d\n", NewModes));
300  while (NewModes--)
301  {
302  /* Get info on mode */
303  VideoDebugPrint((0, "Getting info of mode %lx.\n", *ThisMode));
304  VideoPortZeroMemory(&BiosArguments, sizeof(BiosArguments));
305  BiosArguments.Eax = VBE_GET_MODE_INFORMATION;
306  BiosArguments.Ecx = *ThisMode;
307  BiosArguments.Edi = TrampolineMemoryOffset;
308  BiosArguments.SegEs = TrampolineMemorySegment;
309  Status = VgaExtension->Int10Interface.Int10CallBios(Context, &BiosArguments);
310  if (Status != NO_ERROR) goto Next;
311  if (VBE_GETRETURNCODE(BiosArguments.Eax) != VBE_SUCCESS) goto Next;
312  Status = VgaExtension->Int10Interface.Int10ReadMemory(Context,
313  TrampolineMemorySegment,
314  TrampolineMemoryOffset,
315  VbeModeInfo,
316  256);
317  if (Status != NO_ERROR) goto Next;
318 
319  /* Parse graphics modes only if linear framebuffer support */
320  VideoDebugPrint((0, "attr: %lx\n", VbeModeInfo->ModeAttributes));
321  if (!(VbeModeInfo->ModeAttributes & (VBE_MODEATTR_VALID |
322  VBE_MODEATTR_GRAPHICS))) goto Next;
323  LinearAddressing = ((VbeVersion >= 0x200) &&
324  (VbeModeInfo->PhysBasePtr) &&
325  (VbeModeInfo->ModeAttributes & VBE_MODEATTR_LINEAR)) ?
326  TRUE : FALSE;
327 
328  /* Check SVGA modes if 8bpp or higher */
329  VideoDebugPrint((0, "PhysBase: %lx\n", VbeModeInfo->PhysBasePtr));
330  if ((VbeModeInfo->XResolution >= 640) &&
331  (VbeModeInfo->YResolution >= 480) &&
332  (VbeModeInfo->NumberOfPlanes >= 1) &&
333  (VbeModeInfo->BitsPerPixel >= 8))
334  {
335  /* Copy VGA mode info */
337  VgaMode->numPlanes = VbeModeInfo->NumberOfPlanes;
338  VgaMode->hres = VbeModeInfo->XResolution;
339  VgaMode->vres = VbeModeInfo->YResolution;
340  VgaMode->Frequency = 1;
341  VgaMode->Mode = (*ThisMode << 16) | VBE_SET_VBE_MODE;
342  VgaMode->Granularity = VbeModeInfo->WinGranularity << 10;
343  VideoDebugPrint((0, "Mode %lx (Granularity %d)\n", VgaMode->Mode, VgaMode->Granularity));
344 
345  /* Set flags */
346  if (VbeModeInfo->ModeAttributes & VBE_MODEATTR_COLOR) VgaMode->fbType |= VIDEO_MODE_COLOR;
347  if (VbeModeInfo->ModeAttributes & VBE_MODEATTR_GRAPHICS) VgaMode->fbType |= VIDEO_MODE_GRAPHICS;
348  if (VbeModeInfo->ModeAttributes & VBE_MODEATTR_NON_VGA) VgaMode->NonVgaMode = TRUE;
349 
350  /* If no char data, say 80x25 */
351  VgaMode->col = VbeModeInfo->XCharSize ? VbeModeInfo->XResolution / VbeModeInfo->XCharSize : 80;
352  VgaMode->row = VbeModeInfo->YCharSize ? VbeModeInfo->YResolution / VbeModeInfo->YCharSize : 25;
353  VideoDebugPrint((0, "%d by %d rows\n", VgaMode->col, VgaMode->row));
354 
355  /* Check RGB555 (15bpp only) */
356  VgaMode->bitsPerPlane = VbeModeInfo->BitsPerPixel / VbeModeInfo->NumberOfPlanes;
357  if ((VgaMode->bitsPerPlane == 16) && (VbeModeInfo->GreenMaskSize == 5)) VgaMode->bitsPerPlane = 15;
358  VideoDebugPrint((0, "BPP: %d\n", VgaMode->bitsPerPlane));
359 
360  /* Do linear or banked frame buffers */
361  VgaMode->FrameBufferBase = 0;
362  if (!LinearAddressing)
363  {
364  /* Read the screen stride (scanline size) */
365  ScreenStride = RaiseToPower2(VbeModeInfo->BytesPerScanLine);
366  //ASSERT(ScreenStride <= MAX_USHORT);
367  VgaMode->wbytes = (USHORT)ScreenStride;
368  VideoDebugPrint((0, "ScanLines: %lx Stride: %lx\n", VbeModeInfo->BytesPerScanLine, VgaMode->wbytes));
369 
370  /* Size of frame buffer is Height X ScanLine, align to bank/page size */
371  ScreenSize = VgaMode->hres * ScreenStride;
372  VideoDebugPrint((0, "Size: %lx\n", ScreenSize));
373  Size = (ScreenSize + ((64 * 1024) - 1)) & ((64 * 1024) - 1);
374  VideoDebugPrint((0, "Size: %lx\n", ScreenSize));
375  if (Size > TotalMemory) Size = (Size + ((4 * 1024) - 1)) & ((4 * 1024) - 1);
376  VideoDebugPrint((0, "Size: %lx\n", ScreenSize));
377 
378  /* Banked VGA at 0xA0000 (64K) */
379  VideoDebugPrint((0, "Final size: %lx\n", Size));
380  VgaMode->fbType |= VIDEO_MODE_BANKED;
381  VgaMode->sbytes = Size;
382  VgaMode->PhysSize = 64 * 1024;
383  VgaMode->FrameBufferSize = 64 * 1024;
384  VgaMode->NoBankSwitch = TRUE;
385  VgaMode->PhysBase = 0xA0000;
386  VgaMode->LogicalWidth = RaiseToPower2(VgaMode->hres);
387  }
388  else
389  {
390  /* VBE 3.00+ has specific field, read legacy field if not */
391  VideoDebugPrint((0, "LINEAR MODE!!!\n"));
392  ScreenStride = (VbeVersion >= 0x300) ? VbeModeInfo->LinBytesPerScanLine : 0;
393  if (!ScreenStride) ScreenStride = VbeModeInfo->BytesPerScanLine;
394  //ASSERT(ScreenStride <= MAX_USHORT);
395  VgaMode->wbytes = (USHORT)ScreenStride;
396  VideoDebugPrint((0, "ScanLines: %lx Stride: %lx\n", VbeModeInfo->BytesPerScanLine, VgaMode->wbytes));
397 
398  /* Size of frame buffer is Height X ScanLine, align to page size */
399  ScreenSize = VgaMode->hres * LOWORD(VgaMode->wbytes);
400  VideoDebugPrint((0, "Size: %lx\n", ScreenSize));
401  Size = RaiseToPower2Ulong(ScreenSize);
402  VideoDebugPrint((0, "Size: %lx\n", ScreenSize));
403  if (Size > TotalMemory) Size = (Size + ((4 * 1024) - 1)) & ((4 * 1024) - 1);
404  VideoDebugPrint((0, "Size: %lx\n", ScreenSize));
405 
406  /* Linear VGA must read settings from VBE */
407  VgaMode->fbType |= VIDEO_MODE_LINEAR;
408  VgaMode->sbytes = Size;
409  VgaMode->PhysSize = Size;
410  VgaMode->FrameBufferSize = Size;
411  VgaMode->NoBankSwitch = FALSE;
412  VgaMode->PhysBase = VbeModeInfo->PhysBasePtr;
413  VgaMode->LogicalWidth = VgaMode->hres;
414 
415  /* Make VBE_SET_VBE_MODE command use Linear Framebuffer Select */
416  VgaMode->Mode |= (VBE_MODE_LINEAR_FRAMEBUFFER << 16);
417  }
418 
419  /* Override bank switch if not support by card */
420  if (VbeModeInfo->ModeAttributes & VBE_MODEATTR_NO_BANK_SWITCH) VgaMode->NoBankSwitch = TRUE;
421 
422  /* Next */
423  if (ScreenSize <= TotalMemory)
424  {
425  VgaMode++;
426  ModeCount++;
427  }
428  }
429 Next:
430  /* Next */
431  ThisMode++;
432  }
433 
434  /* Check if last mode was color to do test */
435  VideoDebugPrint((0, "mode scan complete. Total modes: %d\n", ModeCount));
436  if (--VgaMode->fbType & VIDEO_MODE_COLOR)
437  {
438  /* Try map physical buffer and free if worked */
439  PhysicalAddress.QuadPart = VgaMode->PhysBase;
440  BaseAddress = VideoPortGetDeviceBase(VgaExtension, PhysicalAddress, 4 * 1024, FALSE);
441  if (BaseAddress)
442  {
443  VideoPortFreeDeviceBase(VgaExtension, BaseAddress);
444  }
445  else
446  {
447  /* Not work, so throw out VBE data */
448  ModeCount = 0;
449  }
450  }
451 
452  /* Cleanup sucess path */
453  VideoPortFreePool(VgaExtension, VbeInfo);
454  VgaExtension->Int10Interface.Int10FreeBuffer(Context,
455  TrampolineMemorySegment,
456  TrampolineMemoryOffset);
457  NumVideoModes += ModeCount;
458  return;
459 
460 Cleanup:
461  /* Cleanup failure path, reset standard VGA and free memory */
463  VideoPortFreePool(VgaExtension, VbeInfo);
464  VgaExtension->Int10Interface.Int10FreeBuffer(Context,
465  TrampolineMemorySegment,
466  TrampolineMemoryOffset);
467 }
468 
469 /* EOF */
_In_opt_ ULONG _Out_ PULONG Value
Definition: rtlfuncs.h:2343
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define VBE_MODE_BITS
Definition: vbe.h:65
ULONG NTAPI VbeGetVideoMemoryBaseAddress(IN PHW_DEVICE_EXTENSION VgaExtension, IN PVIDEOMODE VgaMode)
Definition: vbemodes.c:35
ULONG PhysBasePtr
Definition: vbe.h:155
#define VIDEO_PORT_INT10_INTERFACE_VERSION_1
Definition: video.h:127
VPAPI VP_STATUS NTAPI VideoPortQueryServices(IN PVOID HwDeviceExtension, IN VIDEO_PORT_SERVICES ServicesType, IN OUT PINTERFACE Interface)
Definition: services.c:40
#define IN
Definition: typedefs.h:38
USHORT Version
Definition: vbemp.h:110
#define TRUE
Definition: types.h:120
ULONG NumVideoModes
Definition: vgadata.c:433
_In_ ULONG Mode
Definition: hubbusif.h:303
#define VBE_SET_GET_LOGICAL_SCAN_LINE_LENGTH
Definition: vbemp.h:52
#define VBE2_MAGIC
Definition: vbe.h:219
BYTE GreenMaskSize
Definition: vbe.h:82
USHORT ModeAttributes
Definition: vbe.h:120
#define VBE_MODEATTR_NON_VGA
Definition: vbe.h:61
#define VBE_GETRETURNCODE(x)
Definition: vbemp.h:100
UCHAR XCharSize
Definition: vbe.h:133
VPAPI PVOID NTAPI VideoPortGetDeviceBase(IN PVOID HwDeviceExtension, IN PHYSICAL_ADDRESS IoAddress, IN ULONG NumberOfUchars, IN UCHAR InIoSpace)
Definition: resource.c:450
#define NO_ERROR
Definition: dderror.h:5
PVIDEOMODE VgaModeList
Definition: vgadata.c:434
VPAPI VOID NTAPI VideoPortZeroMemory(IN PVOID Destination, IN ULONG Length)
VP_STATUS NTAPI VbeSetMode(IN PHW_DEVICE_EXTENSION VgaDeviceExtension, IN PVIDEOMODE VgaMode, OUT PULONG PhysPtrChange)
Definition: vbemodes.c:88
Definition: vga.h:250
#define VBE_GET_MODE_INFORMATION
Definition: vbemp.h:47
#define VBE_MODEATTR_NO_BANK_SWITCH
Definition: vbe.h:62
VIDEOMODE ModesVGA[]
Definition: vgadata.c:281
#define VBE_SUCCESS
Definition: vbemp.h:95
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
VPAPI PVOID NTAPI VideoPortAllocatePool(IN PVOID HwDeviceExtension, IN VP_POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN ULONG Tag)
Definition: resource.c:913
ULONG NTAPI RaiseToPower2Ulong(IN ULONG Value)
Definition: vbemodes.c:17
unsigned char BOOLEAN
#define VBE_MODEATTR_COLOR
Definition: vbe.h:59
BOOLEAN NTAPI ValidateVbeInfo(IN PHW_DEVICE_EXTENSION VgaExtension, IN PVBE_INFO VbeInfo)
Definition: vbe.c:78
VPAPI VOID NTAPI VideoPortFreePool(IN PVOID HwDeviceExtension, IN PVOID Ptr)
Definition: resource.c:928
#define VBE_MODEATTR_GRAPHICS
Definition: vbe.h:60
#define VBE_GET_CONTROLLER_INFORMATION
Definition: vbemp.h:46
VPAPI VP_STATUS NTAPI VideoPortInt10(IN PVOID HwDeviceExtension, IN PVIDEO_X86_BIOS_ARGUMENTS BiosArguments)
Definition: int10.c:389
USHORT WinGranularity
Definition: vbe.h:123
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
BOOLEAN g_bIntelBrookdaleBIOS
Definition: vbe.c:31
if(!(yy_init))
Definition: macro.lex.yy.c:714
USHORT LinBytesPerScanLine
Definition: vbe.h:160
BYTE BitsPerPixel
Definition: vbe.h:74
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
#define VIDEO_MODE_BANKED
Definition: ntddvdeo.h:300
#define VBE_MODE_LINEAR_FRAMEBUFFER
Definition: vbe.h:71
USHORT BytesPerScanLine
Definition: vbe.h:128
#define VBE_GET_CURRENT_VBE_MODE
Definition: vbemp.h:49
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS PhysicalAddress
Definition: iotypes.h:1061
#define VBE_SET_VBE_MODE
Definition: vbemp.h:48
struct _VIDEO_PORT_INT10_INTERFACE VIDEO_PORT_INT10_INTERFACE
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
static const WCHAR Cleanup[]
Definition: register.c:80
USHORT XResolution
Definition: vbe.h:131
Status
Definition: gdiplustypes.h:24
#define VBE_MODEATTR_LINEAR
Definition: vbemp.h:86
VPAPI BOOLEAN NTAPI VideoPortIsNoVesa(VOID)
Definition: videoprt.c:1397
VPAPI VOID NTAPI VideoPortMoveMemory(IN PVOID Destination, IN PVOID Source, IN ULONG Length)
#define VideoDebugPrint(x)
Definition: video.h:75
#define VIDEO_MODE_LINEAR
Definition: ntddvdeo.h:301
unsigned short USHORT
Definition: pedump.c:61
#define VIDEO_MODE_COLOR
Definition: ntddvdeo.h:293
VPAPI VOID NTAPI VideoPortFreeDeviceBase(IN PVOID HwDeviceExtension, IN PVOID MappedAddress)
Definition: resource.c:471
unsigned int * PULONG
Definition: retypes.h:1
ULONG VideoModePtr
Definition: vbemp.h:113
VOID NTAPI InitializeModeTable(IN PHW_DEVICE_EXTENSION VgaExtension)
Definition: vbemodes.c:159
USHORT TotalMemory
Definition: vbemp.h:114
static BOOLEAN VgaMode
Definition: options.c:87
#define OUT
Definition: typedefs.h:39
UCHAR YCharSize
Definition: vbe.h:134
struct tagContext Context
Definition: acpixf.h:1024
#define HIWORD(l)
Definition: typedefs.h:246
unsigned int ULONG
Definition: retypes.h:1
LONG VP_STATUS
Definition: video.h:153
UCHAR NumberOfPlanes
Definition: vbe.h:135
ULONG NTAPI RaiseToPower2(IN USHORT Value)
Definition: vbemodes.c:26
#define LOWORD(l)
Definition: pedump.c:82
unsigned short * PUSHORT
Definition: retypes.h:2
#define VBE_MODEATTR_VALID
Definition: vbe.h:58
LONGLONG QuadPart
Definition: typedefs.h:112
CHAR Signature[4]
Definition: vbemp.h:109
USHORT YResolution
Definition: vbe.h:132
#define VIDEO_MODE_GRAPHICS
Definition: ntddvdeo.h:294