[HNETCFG] Sync with Wine 3.0. CORE-14225
[reactos.git] / win32ss / drivers / videoprt / agp.c
1 /*
2 * VideoPort driver
3 *
4 * Copyright (C) 2002, 2003, 2004 ReactOS Team
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 */
21
22 #include "videoprt.h"
23
24 #define NDEBUG
25 #include <debug.h>
26
27 /* PRIVATE FUNCTIONS **********************************************************/
28
29 NTSTATUS
30 IopInitiatePnpIrp(
31 PDEVICE_OBJECT DeviceObject,
32 PIO_STATUS_BLOCK IoStatusBlock,
33 UCHAR MinorFunction,
34 PIO_STACK_LOCATION Stack OPTIONAL)
35 {
36 PDEVICE_OBJECT TopDeviceObject;
37 PIO_STACK_LOCATION IrpSp;
38 NTSTATUS Status;
39 KEVENT Event;
40 PIRP Irp;
41
42 /* Always call the top of the device stack */
43 TopDeviceObject = IoGetAttachedDeviceReference(DeviceObject);
44
45 KeInitializeEvent(
46 &Event,
47 NotificationEvent,
48 FALSE);
49
50 Irp = IoBuildSynchronousFsdRequest(
51 IRP_MJ_PNP,
52 TopDeviceObject,
53 NULL,
54 0,
55 NULL,
56 &Event,
57 IoStatusBlock);
58
59 /* PNP IRPs are always initialized with a status code of
60 STATUS_NOT_SUPPORTED */
61 Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
62 Irp->IoStatus.Information = 0;
63
64 IrpSp = IoGetNextIrpStackLocation(Irp);
65 IrpSp->MinorFunction = MinorFunction;
66
67 if (Stack)
68 {
69 RtlMoveMemory(
70 &IrpSp->Parameters,
71 &Stack->Parameters,
72 sizeof(Stack->Parameters));
73 }
74
75 Status = IoCallDriver(TopDeviceObject, Irp);
76 if (Status == STATUS_PENDING)
77 {
78 KeWaitForSingleObject(
79 &Event,
80 Executive,
81 KernelMode,
82 FALSE,
83 NULL);
84 Status = IoStatusBlock->Status;
85 }
86
87 ObDereferenceObject(TopDeviceObject);
88
89 return Status;
90 }
91
92
93 BOOLEAN NTAPI
94 IntAgpCommitPhysical(
95 IN PVOID HwDeviceExtension,
96 IN PVOID PhysicalContext,
97 IN ULONG Pages,
98 IN ULONG Offset)
99 {
100 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
101 PAGP_BUS_INTERFACE_STANDARD AgpBusInterface;
102 PHYSICAL_ADDRESS MappingAddr = {{0, 0}};
103 PVIDEO_PORT_AGP_MAPPING AgpMapping;
104 NTSTATUS Status;
105
106 TRACE_(VIDEOPRT, "AgpCommitPhysical - PhysicalContext: 0x%x Pages: %d, Offset: 0x%x\n",
107 PhysicalContext, Pages, Offset);
108
109 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
110 AgpBusInterface = &DeviceExtension->AgpInterface;
111 AgpMapping = (PVIDEO_PORT_AGP_MAPPING)PhysicalContext;
112
113 Status = AgpBusInterface->CommitMemory(AgpBusInterface->AgpContext,
114 AgpMapping->MapHandle, Pages, Offset,
115 NULL, &MappingAddr);
116
117 if (!NT_SUCCESS(Status))
118 {
119 WARN_(VIDEOPRT, "Warning: AgpBusInterface->CommitMemory failed (Status = 0x%x)\n",
120 Status);
121 }
122 return NT_SUCCESS(Status);
123 }
124
125 VOID NTAPI
126 IntAgpFreePhysical(
127 IN PVOID HwDeviceExtension,
128 IN PVOID PhysicalContext,
129 IN ULONG Pages,
130 IN ULONG Offset)
131 {
132 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
133 PAGP_BUS_INTERFACE_STANDARD AgpBusInterface;
134 PVIDEO_PORT_AGP_MAPPING AgpMapping;
135 NTSTATUS Status;
136
137 TRACE_(VIDEOPRT, "AgpFreePhysical - PhysicalContext: 0x%x Pages: %d, Offset: 0x%x\n",
138 PhysicalContext, Pages, Offset);
139
140 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
141 AgpBusInterface = &DeviceExtension->AgpInterface;
142 AgpMapping = (PVIDEO_PORT_AGP_MAPPING)PhysicalContext;
143
144 Status = AgpBusInterface->FreeMemory(AgpBusInterface->AgpContext,
145 AgpMapping->MapHandle, Pages, Offset);
146 if (!NT_SUCCESS(Status))
147 {
148 WARN_(VIDEOPRT, "Warning: AgpBusInterface->FreeMemory failed (Status = 0x%x)\n",
149 Status);
150 }
151 }
152
153 VOID NTAPI
154 IntAgpReleasePhysical(
155 IN PVOID HwDeviceExtension,
156 IN PVOID PhysicalContext)
157 {
158 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
159 PAGP_BUS_INTERFACE_STANDARD AgpBusInterface;
160 PVIDEO_PORT_AGP_MAPPING AgpMapping;
161 NTSTATUS Status;
162
163 TRACE_(VIDEOPRT, "AgpReleasePhysical - PhysicalContext: 0x%x\n", PhysicalContext);
164
165 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
166 AgpBusInterface = &DeviceExtension->AgpInterface;
167 AgpMapping = (PVIDEO_PORT_AGP_MAPPING)PhysicalContext;
168
169 /* Release memory */
170 Status = AgpBusInterface->ReleaseMemory(AgpBusInterface->AgpContext,
171 AgpMapping->MapHandle);
172 if (!NT_SUCCESS(Status))
173 {
174 WARN_(VIDEOPRT, "Warning: AgpBusInterface->ReleaseMemory failed (Status = 0x%x)\n",
175 Status);
176 }
177
178 /* Free resources */
179 ExFreePool(AgpMapping);
180 }
181
182 PHYSICAL_ADDRESS NTAPI
183 IntAgpReservePhysical(
184 IN PVOID HwDeviceExtension,
185 IN ULONG Pages,
186 IN VIDEO_PORT_CACHE_TYPE Caching,
187 OUT PVOID *PhysicalContext)
188 {
189 PHYSICAL_ADDRESS ZeroAddress = {{0, 0}};
190 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
191 PAGP_BUS_INTERFACE_STANDARD AgpBusInterface;
192 MEMORY_CACHING_TYPE MemCachingType;
193 PVIDEO_PORT_AGP_MAPPING AgpMapping;
194 NTSTATUS Status;
195
196 TRACE_(VIDEOPRT, "AgpReservePhysical - Pages: %d, Caching: 0x%x\n", Pages, Caching);
197
198 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
199 AgpBusInterface = &DeviceExtension->AgpInterface;
200
201 /* Translate memory caching type */
202 if (Caching == VpNonCached)
203 MemCachingType = MmNonCached;
204 else if (Caching == VpCached)
205 MemCachingType = MmCached;
206 else if (Caching == VpWriteCombined)
207 MemCachingType = MmWriteCombined;
208 else
209 {
210 WARN_(VIDEOPRT, "Invalid caching type %d!\n", Caching);
211 return ZeroAddress;
212 }
213
214 /* Allocate an AGP mapping structure */
215 AgpMapping = ExAllocatePoolWithTag(PagedPool,
216 sizeof(VIDEO_PORT_AGP_MAPPING),
217 TAG_VIDEO_PORT);
218 if (AgpMapping == NULL)
219 {
220 WARN_(VIDEOPRT, "Out of memory! Couldn't allocate AGP mapping structure!\n");
221 return ZeroAddress;
222 }
223 RtlZeroMemory(AgpMapping, sizeof(VIDEO_PORT_AGP_MAPPING));
224
225 /* Reserve memory for the AGP bus */
226 Status = AgpBusInterface->ReserveMemory(AgpBusInterface->AgpContext,
227 Pages,
228 MemCachingType,
229 &AgpMapping->MapHandle,
230 &AgpMapping->PhysicalAddress);
231 if (!NT_SUCCESS(Status) || AgpMapping->MapHandle == NULL)
232 {
233 ExFreePool(AgpMapping);
234 WARN_(VIDEOPRT, "Warning: AgpBusInterface->ReserveMemory failed (Status = 0x%x)\n",
235 Status);
236 return ZeroAddress;
237 }
238
239 /* Fill the rest of the AGP mapping */
240 AgpMapping->NumberOfPages = Pages;
241
242 *PhysicalContext = (PVOID)AgpMapping;
243 return AgpMapping->PhysicalAddress;
244 }
245
246
247 PVOID NTAPI
248 IntAgpCommitVirtual(
249 IN PVOID HwDeviceExtension,
250 IN PVOID VirtualContext,
251 IN ULONG Pages,
252 IN ULONG Offset)
253 {
254 PVIDEO_PORT_AGP_VIRTUAL_MAPPING VirtualMapping;
255 PVOID BaseAddress = NULL;
256 PHYSICAL_ADDRESS PhysicalAddress;
257 NTSTATUS Status;
258
259 TRACE_(VIDEOPRT, "AgpCommitVirtual - VirtualContext: 0x%x Pages: %d, Offset: 0x%x\n",
260 VirtualContext, Pages, Offset);
261
262 VirtualMapping = (PVIDEO_PORT_AGP_VIRTUAL_MAPPING)VirtualContext;
263
264 /* I think the NT API provides no way of reserving a part of the address space
265 * and setting it up to map into a specified range of physical memory later.
266 * This means that we will have to release some of the reserved virtual memory
267 * and map the physical memory into it using MapViewOfSection.
268 *
269 * - blight (2004-12-21)
270 */
271
272 if (VirtualMapping->ProcessHandle == NULL)
273 {
274 /* FIXME: not implemented */
275 }
276 else /* ProcessHandle != NULL */
277 {
278 /* Release some virtual memory */
279 SIZE_T Size = Pages * PAGE_SIZE;
280 ULONG OffsetInBytes = Offset * PAGE_SIZE;
281 BaseAddress = (PVOID)((ULONG_PTR)VirtualMapping->MappedAddress +
282 OffsetInBytes);
283 PhysicalAddress = VirtualMapping->AgpMapping->PhysicalAddress;
284 PhysicalAddress.QuadPart += OffsetInBytes;
285
286 Status = ZwFreeVirtualMemory(VirtualMapping->ProcessHandle,
287 &BaseAddress,
288 &Size, MEM_RELEASE);
289 if (!NT_SUCCESS(Status))
290 {
291 WARN_(VIDEOPRT, "Warning: ZwFreeVirtualMemory() failed: Status = 0x%x\n", Status);
292 return NULL;
293 }
294 ASSERT(Size == Pages * PAGE_SIZE);
295 ASSERT(BaseAddress == (PVOID)((ULONG_PTR)VirtualMapping->MappedAddress +
296 OffsetInBytes));
297
298 /* Map the physical memory into the released virtual memory area */
299 Status = IntVideoPortMapPhysicalMemory(VirtualMapping->ProcessHandle,
300 PhysicalAddress,
301 Size,
302 PAGE_READWRITE,
303 &BaseAddress);
304 if (!NT_SUCCESS(Status))
305 {
306 WARN_(VIDEOPRT, "Warning: IntVideoPortMapPhysicalMemory() failed: Status = 0x%x\n", Status);
307 /* Reserve the released virtual memory area again */
308 Status = ZwAllocateVirtualMemory(VirtualMapping->ProcessHandle,
309 &BaseAddress, 0, &Size, MEM_RESERVE,
310 PAGE_NOACCESS);
311 if (!NT_SUCCESS(Status))
312 {
313 WARN_(VIDEOPRT, "Warning: ZwAllocateVirtualMemory() failed: Status = 0x%x\n", Status);
314 /* FIXME: What to do now?? */
315 ASSERT(0);
316 return NULL;
317 }
318 ASSERT(Size == Pages * PAGE_SIZE);
319 ASSERT(BaseAddress == (PVOID)((ULONG_PTR)VirtualMapping->MappedAddress +
320 OffsetInBytes));
321 return NULL;
322 }
323 ASSERT(BaseAddress == (PVOID)((ULONG_PTR)VirtualMapping->MappedAddress +
324 OffsetInBytes));
325 }
326
327 return BaseAddress;
328 }
329
330 VOID NTAPI
331 IntAgpFreeVirtual(
332 IN PVOID HwDeviceExtension,
333 IN PVOID VirtualContext,
334 IN ULONG Pages,
335 IN ULONG Offset)
336 {
337 PVIDEO_PORT_AGP_VIRTUAL_MAPPING VirtualMapping;
338 PVOID BaseAddress = NULL;
339 NTSTATUS Status;
340
341 TRACE_(VIDEOPRT, "AgpFreeVirtual - VirtualContext: 0x%x Pages: %d, Offset: 0x%x\n",
342 VirtualContext, Pages, Offset);
343
344 VirtualMapping = (PVIDEO_PORT_AGP_VIRTUAL_MAPPING)VirtualContext;
345
346 if (VirtualMapping->ProcessHandle == NULL)
347 {
348 /* FIXME: not implemented */
349 }
350 else /* ProcessHandle != NULL */
351 {
352 /* Unmap the section view */
353 SIZE_T Size = Pages * PAGE_SIZE;
354 ULONG OffsetInBytes = Offset * PAGE_SIZE;
355 BaseAddress = (PVOID)((ULONG_PTR)VirtualMapping->MappedAddress +
356 OffsetInBytes);
357
358 Status = ZwUnmapViewOfSection(VirtualMapping->ProcessHandle, BaseAddress);
359 if (!NT_SUCCESS(Status))
360 {
361 WARN_(VIDEOPRT, "Warning: ZwUnmapViewOfSection() failed: Status = 0x%x\n", Status);
362 /* FIXME: What to do now?? */
363 ASSERT(0);
364 return;
365 }
366
367 /* And reserve the virtual memory area again */
368 Status = ZwAllocateVirtualMemory(VirtualMapping->ProcessHandle,
369 &BaseAddress, 0, &Size, MEM_RESERVE,
370 PAGE_NOACCESS);
371 if (!NT_SUCCESS(Status))
372 {
373 WARN_(VIDEOPRT, "Warning: ZwAllocateVirtualMemory() failed: Status = 0x%x\n", Status);
374 /* FIXME: What to do now?? */
375 ASSERT(0);
376 return;
377 }
378 ASSERT(Size == Pages * PAGE_SIZE);
379 ASSERT(BaseAddress == (PVOID)((ULONG_PTR)VirtualMapping->MappedAddress +
380 OffsetInBytes));
381 }
382 }
383
384 VOID NTAPI
385 IntAgpReleaseVirtual(
386 IN PVOID HwDeviceExtension,
387 IN PVOID VirtualContext)
388 {
389 PVIDEO_PORT_AGP_VIRTUAL_MAPPING VirtualMapping;
390 NTSTATUS Status;
391
392 TRACE_(VIDEOPRT, "AgpReleaseVirtual - VirtualContext: 0x%x\n", VirtualContext);
393
394 VirtualMapping = (PVIDEO_PORT_AGP_VIRTUAL_MAPPING)VirtualContext;
395
396 /* Release the virtual memory */
397 if (VirtualMapping->ProcessHandle == NULL)
398 {
399 /* FIXME: not implemented */
400 }
401 else /* ProcessHandle != NULL */
402 {
403 /* Release the allocated virtual memory */
404 SIZE_T Size = VirtualMapping->AgpMapping->NumberOfPages * PAGE_SIZE;
405 Status = ZwFreeVirtualMemory(VirtualMapping->ProcessHandle,
406 &VirtualMapping->MappedAddress,
407 &Size, MEM_RELEASE);
408 if (!NT_SUCCESS(Status))
409 {
410 WARN_(VIDEOPRT, "Warning: ZwFreeVirtualMemory() failed: Status = 0x%x\n", Status);
411 }
412 }
413
414 /* Free resources */
415 ExFreePool(VirtualMapping);
416 }
417
418 PVOID NTAPI
419 IntAgpReserveVirtual(
420 IN PVOID HwDeviceExtension,
421 IN HANDLE ProcessHandle,
422 IN PVOID PhysicalContext,
423 OUT PVOID *VirtualContext)
424 {
425 PVIDEO_PORT_AGP_MAPPING AgpMapping;
426 PVIDEO_PORT_AGP_VIRTUAL_MAPPING VirtualMapping;
427 PVOID MappedAddress;
428 NTSTATUS Status;
429
430 TRACE_(VIDEOPRT, "AgpReserveVirtual - ProcessHandle: 0x%x PhysicalContext: 0x%x\n",
431 ProcessHandle, PhysicalContext);
432
433 AgpMapping = (PVIDEO_PORT_AGP_MAPPING)PhysicalContext;
434
435 /* Allocate an AGP virtual mapping structure */
436 VirtualMapping = ExAllocatePoolWithTag(PagedPool,
437 sizeof(VIDEO_PORT_AGP_VIRTUAL_MAPPING),
438 TAG_VIDEO_PORT);
439 if (VirtualMapping == NULL)
440 {
441 WARN_(VIDEOPRT, "Out of memory! Couldn't allocate AGP virtual mapping structure!\n");
442 return NULL;
443 }
444 RtlZeroMemory(VirtualMapping, sizeof(VIDEO_PORT_AGP_VIRTUAL_MAPPING));
445
446 /* Reserve a virtual memory area for the physical pages. */
447 if (ProcessHandle == NULL)
448 {
449 /* FIXME: What to do in this case? */
450 ExFreePool(VirtualMapping);
451 return NULL;
452 }
453 else /* ProcessHandle != NULL */
454 {
455 /* Reserve memory for usermode */
456 SIZE_T Size = AgpMapping->NumberOfPages * PAGE_SIZE;
457 MappedAddress = NULL;
458 Status = ZwAllocateVirtualMemory(ProcessHandle, &MappedAddress, 0, &Size,
459 MEM_RESERVE, PAGE_NOACCESS);
460 if (!NT_SUCCESS(Status))
461 {
462 ExFreePool(VirtualMapping);
463 WARN_(VIDEOPRT, "ZwAllocateVirtualMemory() failed: Status = 0x%x\n", Status);
464 return NULL;
465 }
466 }
467
468 /* Fill the AGP virtual mapping */
469 VirtualMapping->AgpMapping = AgpMapping;
470 VirtualMapping->ProcessHandle = ProcessHandle;
471 VirtualMapping->MappedAddress = MappedAddress;
472
473 *VirtualContext = (PVOID)VirtualMapping;
474 return MappedAddress;
475 }
476
477
478 BOOLEAN NTAPI
479 IntAgpSetRate(
480 IN PVOID HwDeviceExtension,
481 IN ULONG Rate)
482 {
483 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
484 PAGP_BUS_INTERFACE_STANDARD AgpBusInterface;
485
486 TRACE_(VIDEOPRT, "AgpSetRate - Rate: %d\n", Rate);
487
488 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
489 AgpBusInterface = &DeviceExtension->AgpInterface;
490
491 return NT_SUCCESS(AgpBusInterface->SetRate(AgpBusInterface->AgpContext, Rate));
492 }
493
494
495 NTSTATUS NTAPI
496 IntAgpGetInterface(
497 IN PVOID HwDeviceExtension,
498 IN OUT PINTERFACE Interface)
499 {
500 IO_STATUS_BLOCK IoStatusBlock;
501 IO_STACK_LOCATION IoStack;
502 NTSTATUS Status;
503 PVIDEO_PORT_AGP_INTERFACE_2 AgpInterface;
504 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
505 PAGP_BUS_INTERFACE_STANDARD AgpBusInterface;
506
507 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
508 AgpBusInterface = &DeviceExtension->AgpInterface;
509 AgpInterface = (PVIDEO_PORT_AGP_INTERFACE_2)Interface;
510
511 ASSERT(Interface->Version == VIDEO_PORT_AGP_INTERFACE_VERSION_2 ||
512 Interface->Version == VIDEO_PORT_AGP_INTERFACE_VERSION_1);
513 if (Interface->Version == VIDEO_PORT_AGP_INTERFACE_VERSION_2)
514 {
515 ASSERT(Interface->Size >= sizeof(VIDEO_PORT_AGP_INTERFACE_2));
516 }
517 else if (Interface->Version == VIDEO_PORT_AGP_INTERFACE_VERSION_1)
518 {
519 ASSERT(Interface->Size >= sizeof(VIDEO_PORT_AGP_INTERFACE));
520 }
521
522 if (DeviceExtension->NextDeviceObject == NULL)
523 {
524 WARN_(VIDEOPRT, "DeviceExtension->NextDeviceObject is NULL!\n");
525 return STATUS_UNSUCCESSFUL;
526 }
527
528 /* Query the interface from the AGP bus driver */
529 if (DeviceExtension->AgpInterface.Size == 0)
530 {
531 AgpBusInterface->Size = sizeof(AGP_BUS_INTERFACE_STANDARD);
532 if (Interface->Version == VIDEO_PORT_AGP_INTERFACE_VERSION_1)
533 AgpBusInterface->Version = AGP_BUS_INTERFACE_V1;
534 else /* if (InterfaceVersion == VIDEO_PORT_AGP_INTERFACE_VERSION_2) */
535 AgpBusInterface->Version = AGP_BUS_INTERFACE_V2;
536 IoStack.Parameters.QueryInterface.Size = AgpBusInterface->Size;
537 IoStack.Parameters.QueryInterface.Version = AgpBusInterface->Version;
538 IoStack.Parameters.QueryInterface.Interface = (PINTERFACE)AgpBusInterface;
539 IoStack.Parameters.QueryInterface.InterfaceType =
540 &GUID_AGP_TARGET_BUS_INTERFACE_STANDARD;
541 Status = IopInitiatePnpIrp(DeviceExtension->NextDeviceObject,
542 &IoStatusBlock, IRP_MN_QUERY_INTERFACE, &IoStack);
543 if (!NT_SUCCESS(Status))
544 {
545 WARN_(VIDEOPRT, "IopInitiatePnpIrp() failed! (Status 0x%x)\n", Status);
546 return Status;
547 }
548 INFO_(VIDEOPRT, "Got AGP driver interface!\n");
549 }
550
551 /* FIXME: Not sure if we should wrap the reference/dereference functions */
552 AgpInterface->Context = AgpBusInterface->AgpContext;
553 AgpInterface->InterfaceReference = AgpBusInterface->InterfaceReference;
554 AgpInterface->InterfaceDereference = AgpBusInterface->InterfaceDereference;
555 AgpInterface->AgpReservePhysical = IntAgpReservePhysical;
556 AgpInterface->AgpReleasePhysical = IntAgpReleasePhysical;
557 AgpInterface->AgpCommitPhysical = IntAgpCommitPhysical;
558 AgpInterface->AgpFreePhysical = IntAgpFreePhysical;
559 AgpInterface->AgpReserveVirtual = IntAgpReserveVirtual;
560 AgpInterface->AgpReleaseVirtual = IntAgpReleaseVirtual;
561 AgpInterface->AgpCommitVirtual = IntAgpCommitVirtual;
562 AgpInterface->AgpFreeVirtual = IntAgpFreeVirtual;
563 AgpInterface->AgpAllocationLimit = 0x1000000; /* FIXME: using 16 MB for now */
564
565 if (AgpInterface->Version >= VIDEO_PORT_AGP_INTERFACE_VERSION_2)
566 {
567 AgpInterface->AgpSetRate = IntAgpSetRate;
568 }
569
570 return STATUS_SUCCESS;
571 }