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