[VIDEOPRT]
[reactos.git] / reactos / win32ss / drivers / videoprt / videoprt.c
1 /*
2 * VideoPort driver
3 *
4 * Copyright (C) 2002-2004, 2007 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 #include <stdio.h>
25 #include <ndk/exfuncs.h>
26 #include <ndk/rtlfuncs.h>
27
28 #define NDEBUG
29 #include <debug.h>
30
31 /* GLOBAL VARIABLES ***********************************************************/
32
33 ULONG CsrssInitialized = FALSE;
34 PKPROCESS Csrss = NULL;
35 ULONG VideoPortDeviceNumber = 0;
36
37 /* PRIVATE FUNCTIONS **********************************************************/
38
39 ULONG
40 NTAPI
41 DriverEntry(
42 IN PVOID Context1,
43 IN PVOID Context2)
44 {
45 return STATUS_SUCCESS;
46 }
47
48 PVOID
49 NTAPI
50 IntVideoPortImageDirectoryEntryToData(
51 PVOID BaseAddress,
52 ULONG Directory)
53 {
54 PIMAGE_NT_HEADERS NtHeader;
55 ULONG Va;
56
57 NtHeader = RtlImageNtHeader(BaseAddress);
58 if (NtHeader == NULL)
59 return NULL;
60
61 if (Directory >= NtHeader->OptionalHeader.NumberOfRvaAndSizes)
62 return NULL;
63
64 Va = NtHeader->OptionalHeader.DataDirectory[Directory].VirtualAddress;
65 if (Va == 0)
66 return NULL;
67
68 return (PVOID)((ULONG_PTR)BaseAddress + Va);
69 }
70
71 VOID
72 NTAPI
73 IntVideoPortDeferredRoutine(
74 IN PKDPC Dpc,
75 IN PVOID DeferredContext,
76 IN PVOID SystemArgument1,
77 IN PVOID SystemArgument2)
78 {
79 PVOID HwDeviceExtension =
80 &((PVIDEO_PORT_DEVICE_EXTENSION)DeferredContext)->MiniPortDeviceExtension;
81 ((PMINIPORT_DPC_ROUTINE)SystemArgument1)(HwDeviceExtension, SystemArgument2);
82 }
83
84 NTSTATUS
85 NTAPI
86 IntVideoPortCreateAdapterDeviceObject(
87 IN PDRIVER_OBJECT DriverObject,
88 IN PVIDEO_PORT_DRIVER_EXTENSION DriverExtension,
89 IN PDEVICE_OBJECT PhysicalDeviceObject,
90 OUT PDEVICE_OBJECT *DeviceObject OPTIONAL)
91 {
92 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
93 ULONG DeviceNumber;
94 ULONG PciSlotNumber;
95 PCI_SLOT_NUMBER SlotNumber;
96 ULONG Size;
97 NTSTATUS Status;
98 WCHAR DeviceBuffer[20];
99 UNICODE_STRING DeviceName;
100 PDEVICE_OBJECT DeviceObject_;
101
102 if (DeviceObject == NULL)
103 DeviceObject = &DeviceObject_;
104
105 /*
106 * Find the first free device number that can be used for video device
107 * object names and symlinks.
108 */
109 DeviceNumber = VideoPortDeviceNumber;
110 if (DeviceNumber == 0xFFFFFFFF)
111 {
112 WARN_(VIDEOPRT, "Can't find free device number\n");
113 return STATUS_UNSUCCESSFUL;
114 }
115
116 /*
117 * Create the device object.
118 */
119
120 /* Create a unicode device name. */
121 swprintf(DeviceBuffer, L"\\Device\\Video%lu", DeviceNumber);
122 RtlInitUnicodeString(&DeviceName, DeviceBuffer);
123
124 INFO_(VIDEOPRT, "HwDeviceExtension size is: 0x%x\n",
125 DriverExtension->InitializationData.HwDeviceExtensionSize);
126
127 /* Create the device object. */
128 Size = sizeof(VIDEO_PORT_DEVICE_EXTENSION) +
129 DriverExtension->InitializationData.HwDeviceExtensionSize;
130 Status = IoCreateDevice(DriverObject,
131 Size,
132 &DeviceName,
133 FILE_DEVICE_VIDEO,
134 0,
135 TRUE,
136 DeviceObject);
137
138 if (!NT_SUCCESS(Status))
139 {
140 WARN_(VIDEOPRT, "IoCreateDevice call failed with status 0x%08x\n", Status);
141 return Status;
142 }
143
144 /*
145 * Set the buffering strategy here. If you change this, remember
146 * to change VidDispatchDeviceControl too.
147 */
148
149 (*DeviceObject)->Flags |= DO_BUFFERED_IO;
150
151 /* Initialize device extension. */
152 DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)((*DeviceObject)->DeviceExtension);
153 DeviceExtension->Common.Fdo = TRUE;
154 DeviceExtension->DeviceNumber = DeviceNumber;
155 DeviceExtension->DriverObject = DriverObject;
156 DeviceExtension->PhysicalDeviceObject = PhysicalDeviceObject;
157 DeviceExtension->FunctionalDeviceObject = *DeviceObject;
158 DeviceExtension->DriverExtension = DriverExtension;
159 DeviceExtension->SessionId = -1;
160
161 InitializeListHead(&DeviceExtension->ChildDeviceList);
162
163 /* Get the registry path associated with this device. */
164 Status = IntCreateRegistryPath(&DriverExtension->RegistryPath,
165 &DeviceExtension->RegistryPath);
166 if (!NT_SUCCESS(Status))
167 {
168 WARN_(VIDEOPRT, "IntCreateRegistryPath() call failed with status 0x%08x\n", Status);
169 IoDeleteDevice(*DeviceObject);
170 *DeviceObject = NULL;
171 return Status;
172 }
173
174 if (PhysicalDeviceObject != NULL)
175 {
176 /* Get bus number from the upper level bus driver. */
177 Size = sizeof(ULONG);
178 Status = IoGetDeviceProperty(PhysicalDeviceObject,
179 DevicePropertyBusNumber,
180 Size,
181 &DeviceExtension->SystemIoBusNumber,
182 &Size);
183 if (!NT_SUCCESS(Status))
184 {
185 WARN_(VIDEOPRT, "Couldn't get an information from bus driver. We will try to\n"
186 "use legacy detection method, but even that doesn't mean that\n"
187 "it will work.\n");
188 DeviceExtension->PhysicalDeviceObject = NULL;
189 }
190 }
191
192 DeviceExtension->AdapterInterfaceType =
193 DriverExtension->InitializationData.AdapterInterfaceType;
194
195 if (PhysicalDeviceObject != NULL)
196 {
197 /* Get bus type from the upper level bus driver. */
198 Size = sizeof(ULONG);
199 IoGetDeviceProperty(PhysicalDeviceObject,
200 DevicePropertyLegacyBusType,
201 Size,
202 &DeviceExtension->AdapterInterfaceType,
203 &Size);
204
205 /* Get bus device address from the upper level bus driver. */
206 Size = sizeof(ULONG);
207 IoGetDeviceProperty(PhysicalDeviceObject,
208 DevicePropertyAddress,
209 Size,
210 &PciSlotNumber,
211 &Size);
212
213 /* Convert slotnumber to PCI_SLOT_NUMBER */
214 SlotNumber.u.AsULONG = 0;
215 SlotNumber.u.bits.DeviceNumber = (PciSlotNumber >> 16) & 0xFFFF;
216 SlotNumber.u.bits.FunctionNumber = PciSlotNumber & 0xFFFF;
217 DeviceExtension->SystemIoSlotNumber = SlotNumber.u.AsULONG;
218 }
219
220 InitializeListHead(&DeviceExtension->AddressMappingListHead);
221 InitializeListHead(&DeviceExtension->DmaAdapterList);
222
223 KeInitializeDpc(&DeviceExtension->DpcObject,
224 IntVideoPortDeferredRoutine,
225 DeviceExtension);
226
227 KeInitializeMutex(&DeviceExtension->DeviceLock, 0);
228
229 /* Attach the device. */
230 if (PhysicalDeviceObject != NULL)
231 DeviceExtension->NextDeviceObject = IoAttachDeviceToDeviceStack(
232 *DeviceObject,
233 PhysicalDeviceObject);
234
235 IntCreateNewRegistryPath(DeviceExtension);
236 IntSetupDeviceSettingsKey(DeviceExtension);
237
238 /* Remove the initailizing flag */
239 (*DeviceObject)->Flags &= ~DO_DEVICE_INITIALIZING;
240 return STATUS_SUCCESS;
241 }
242
243
244 NTSTATUS
245 NTAPI
246 IntVideoPortFindAdapter(
247 IN PDRIVER_OBJECT DriverObject,
248 IN PVIDEO_PORT_DRIVER_EXTENSION DriverExtension,
249 IN PDEVICE_OBJECT DeviceObject)
250 {
251 WCHAR DeviceVideoBuffer[20];
252 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
253 SIZE_T Size;
254 NTSTATUS Status;
255 VIDEO_PORT_CONFIG_INFO ConfigInfo;
256 SYSTEM_BASIC_INFORMATION SystemBasicInfo;
257 UCHAR Again = FALSE;
258 WCHAR DeviceBuffer[20];
259 UNICODE_STRING DeviceName;
260 WCHAR SymlinkBuffer[20];
261 UNICODE_STRING SymlinkName;
262 BOOL LegacyDetection = FALSE;
263 ULONG DeviceNumber;
264
265 DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
266 DeviceNumber = DeviceExtension->DeviceNumber;
267
268 /* Setup a ConfigInfo structure that we will pass to HwFindAdapter. */
269 RtlZeroMemory(&ConfigInfo, sizeof(VIDEO_PORT_CONFIG_INFO));
270 ConfigInfo.Length = sizeof(VIDEO_PORT_CONFIG_INFO);
271 ConfigInfo.AdapterInterfaceType = DeviceExtension->AdapterInterfaceType;
272 if (ConfigInfo.AdapterInterfaceType == PCIBus)
273 ConfigInfo.InterruptMode = LevelSensitive;
274 else
275 ConfigInfo.InterruptMode = Latched;
276 ConfigInfo.DriverRegistryPath = DriverExtension->RegistryPath.Buffer;
277 ConfigInfo.VideoPortGetProcAddress = IntVideoPortGetProcAddress;
278 ConfigInfo.SystemIoBusNumber = DeviceExtension->SystemIoBusNumber;
279 ConfigInfo.BusInterruptLevel = DeviceExtension->InterruptLevel;
280 ConfigInfo.BusInterruptVector = DeviceExtension->InterruptVector;
281
282 Size = sizeof(SystemBasicInfo);
283 Status = ZwQuerySystemInformation(SystemBasicInformation,
284 &SystemBasicInfo,
285 Size,
286 &Size);
287 if (NT_SUCCESS(Status))
288 {
289 ConfigInfo.SystemMemorySize = SystemBasicInfo.NumberOfPhysicalPages *
290 SystemBasicInfo.PageSize;
291 }
292
293 /*
294 * Call miniport HwVidFindAdapter entry point to detect if
295 * particular device is present. There are two possible code
296 * paths. The first one is for Legacy drivers (NT4) and cases
297 * when we don't have information about what bus we're on. The
298 * second case is the standard one for Plug & Play drivers.
299 */
300 if (DeviceExtension->PhysicalDeviceObject == NULL)
301 {
302 LegacyDetection = TRUE;
303 }
304
305 if (LegacyDetection)
306 {
307 ULONG BusNumber, MaxBuses;
308
309 MaxBuses = DeviceExtension->AdapterInterfaceType == PCIBus ? PCI_MAX_BRIDGE_NUMBER : 1;
310
311 for (BusNumber = 0; BusNumber < MaxBuses; BusNumber++)
312 {
313 DeviceExtension->SystemIoBusNumber =
314 ConfigInfo.SystemIoBusNumber = BusNumber;
315
316 RtlZeroMemory(&DeviceExtension->MiniPortDeviceExtension,
317 DriverExtension->InitializationData.HwDeviceExtensionSize);
318
319 /* FIXME: Need to figure out what string to pass as param 3. */
320 Status = DriverExtension->InitializationData.HwFindAdapter(
321 &DeviceExtension->MiniPortDeviceExtension,
322 DriverExtension->HwContext,
323 NULL,
324 &ConfigInfo,
325 &Again);
326
327 if (Status == ERROR_DEV_NOT_EXIST)
328 {
329 continue;
330 }
331 else if (Status == NO_ERROR)
332 {
333 break;
334 }
335 else
336 {
337 ERR_(VIDEOPRT, "HwFindAdapter call failed with error 0x%X\n", Status);
338 goto Failure;
339 }
340 }
341 }
342 else
343 {
344 /* FIXME: Need to figure out what string to pass as param 3. */
345 Status = DriverExtension->InitializationData.HwFindAdapter(
346 &DeviceExtension->MiniPortDeviceExtension,
347 DriverExtension->HwContext,
348 NULL,
349 &ConfigInfo,
350 &Again);
351 }
352
353 if (Status != NO_ERROR)
354 {
355 ERR_(VIDEOPRT, "HwFindAdapter call failed with error 0x%X\n", Status);
356 goto Failure;
357 }
358
359 /*
360 * Now we know the device is present, so let's do all additional tasks
361 * such as creating symlinks or setting up interrupts and timer.
362 */
363
364 /* Create a unicode device name. */
365 swprintf(DeviceBuffer, L"\\Device\\Video%lu", DeviceNumber);
366 RtlInitUnicodeString(&DeviceName, DeviceBuffer);
367
368 /* Create symbolic link "\??\DISPLAYx" */
369 swprintf(SymlinkBuffer, L"\\??\\DISPLAY%lu", DeviceNumber + 1);
370 RtlInitUnicodeString(&SymlinkName, SymlinkBuffer);
371 IoCreateSymbolicLink(&SymlinkName, &DeviceName);
372
373 /* Add entry to DEVICEMAP\VIDEO key in registry. */
374 swprintf(DeviceVideoBuffer, L"\\Device\\Video%d", DeviceNumber);
375 RtlWriteRegistryValue(
376 RTL_REGISTRY_DEVICEMAP,
377 L"VIDEO",
378 DeviceVideoBuffer,
379 REG_SZ,
380 DeviceExtension->RegistryPath.Buffer,
381 DeviceExtension->RegistryPath.Length + sizeof(UNICODE_NULL));
382
383 RtlWriteRegistryValue(
384 RTL_REGISTRY_DEVICEMAP,
385 L"VIDEO",
386 L"MaxObjectNumber",
387 REG_DWORD,
388 &DeviceNumber,
389 sizeof(DeviceNumber));
390
391 /* FIXME: Allocate hardware resources for device. */
392
393 /* Allocate interrupt for device. */
394 if (!IntVideoPortSetupInterrupt(DeviceObject, DriverExtension, &ConfigInfo))
395 {
396 Status = STATUS_INSUFFICIENT_RESOURCES;
397 goto Failure;
398 }
399
400 /* Allocate timer for device. */
401 if (!IntVideoPortSetupTimer(DeviceObject, DriverExtension))
402 {
403 if (DeviceExtension->InterruptObject != NULL)
404 IoDisconnectInterrupt(DeviceExtension->InterruptObject);
405 ERR_(VIDEOPRT, "IntVideoPortSetupTimer failed\n");
406 Status = STATUS_INSUFFICIENT_RESOURCES;
407 goto Failure;
408 }
409
410 /* Query children of the device. */
411 VideoPortEnumerateChildren(&DeviceExtension->MiniPortDeviceExtension, NULL);
412
413 INFO_(VIDEOPRT, "STATUS_SUCCESS\n");
414 return STATUS_SUCCESS;
415
416 Failure:
417 RtlFreeUnicodeString(&DeviceExtension->RegistryPath);
418 if (DeviceExtension->NextDeviceObject)
419 IoDetachDevice(DeviceExtension->NextDeviceObject);
420 IoDeleteDevice(DeviceObject);
421 return Status;
422 }
423
424 VOID
425 FASTCALL
426 IntAttachToCSRSS(
427 PKPROCESS *CallingProcess,
428 PKAPC_STATE ApcState)
429 {
430 *CallingProcess = (PKPROCESS)PsGetCurrentProcess();
431 if (*CallingProcess != Csrss)
432 {
433 KeStackAttachProcess(Csrss, ApcState);
434 }
435 }
436
437 VOID
438 FASTCALL
439 IntDetachFromCSRSS(
440 PKPROCESS *CallingProcess,
441 PKAPC_STATE ApcState)
442 {
443 if (*CallingProcess != Csrss)
444 {
445 KeUnstackDetachProcess(ApcState);
446 }
447 }
448
449 /* PUBLIC FUNCTIONS ***********************************************************/
450
451 /*
452 * @implemented
453 */
454 ULONG
455 NTAPI
456 VideoPortInitialize(
457 IN PVOID Context1,
458 IN PVOID Context2,
459 IN PVIDEO_HW_INITIALIZATION_DATA HwInitializationData,
460 IN PVOID HwContext)
461 {
462 PDRIVER_OBJECT DriverObject = Context1;
463 PUNICODE_STRING RegistryPath = Context2;
464 NTSTATUS Status;
465 PVIDEO_PORT_DRIVER_EXTENSION DriverExtension;
466 BOOLEAN PnpDriver = FALSE, LegacyDetection = FALSE;
467
468 TRACE_(VIDEOPRT, "VideoPortInitialize\n");
469
470 /* As a first thing do parameter checks. */
471 if (HwInitializationData->HwInitDataSize > sizeof(VIDEO_HW_INITIALIZATION_DATA))
472 {
473 ERR_(VIDEOPRT, "Invalid HwInitializationData\n");
474 return STATUS_REVISION_MISMATCH;
475 }
476
477 if ((HwInitializationData->HwFindAdapter == NULL) ||
478 (HwInitializationData->HwInitialize == NULL) ||
479 (HwInitializationData->HwStartIO == NULL))
480 {
481 ERR_(VIDEOPRT, "Invalid HwInitializationData\n");
482 return STATUS_INVALID_PARAMETER;
483 }
484
485 switch (HwInitializationData->HwInitDataSize)
486 {
487 /*
488 * NT4 drivers are special case, because we must use legacy method
489 * of detection instead of the Plug & Play one.
490 */
491 case SIZE_OF_NT4_VIDEO_HW_INITIALIZATION_DATA:
492 INFO_(VIDEOPRT, "We were loaded by a Windows NT miniport driver.\n");
493 break;
494
495 case SIZE_OF_W2K_VIDEO_HW_INITIALIZATION_DATA:
496 INFO_(VIDEOPRT, "We were loaded by a Windows 2000 miniport driver.\n");
497 break;
498
499 case sizeof(VIDEO_HW_INITIALIZATION_DATA):
500 INFO_(VIDEOPRT, "We were loaded by a Windows XP or later miniport driver.\n");
501 break;
502
503 default:
504 ERR_(VIDEOPRT, "Invalid HwInitializationData size.\n");
505 return STATUS_UNSUCCESSFUL;
506 }
507
508 /* Set dispatching routines */
509 DriverObject->MajorFunction[IRP_MJ_CREATE] = IntVideoPortDispatchOpen;
510 DriverObject->MajorFunction[IRP_MJ_CLOSE] = IntVideoPortDispatchClose;
511 DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] =
512 IntVideoPortDispatchDeviceControl;
513 DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] =
514 IntVideoPortDispatchDeviceControl;
515 DriverObject->MajorFunction[IRP_MJ_WRITE] =
516 IntVideoPortDispatchWrite; // ReactOS-specific hack
517 DriverObject->DriverUnload = IntVideoPortUnload;
518
519 /* Determine type of the miniport driver */
520 if ((HwInitializationData->HwInitDataSize >=
521 FIELD_OFFSET(VIDEO_HW_INITIALIZATION_DATA, HwQueryInterface)) &&
522 (HwInitializationData->HwSetPowerState != NULL) &&
523 (HwInitializationData->HwGetPowerState != NULL) &&
524 (HwInitializationData->HwGetVideoChildDescriptor != NULL))
525 {
526 INFO_(VIDEOPRT, "The miniport is a PnP miniport driver\n");
527 PnpDriver = TRUE;
528 }
529
530 /* Check if legacy detection should be applied */
531 if (!PnpDriver || HwContext)
532 {
533 INFO_(VIDEOPRT, "Legacy detection for adapter interface %d\n",
534 HwInitializationData->AdapterInterfaceType);
535
536 /* FIXME: Move the code for legacy detection
537 to another function and call it here */
538 LegacyDetection = TRUE;
539 }
540
541 /*
542 * NOTE:
543 * The driver extension can be already allocated in case that we were
544 * called by legacy driver and failed detecting device. Some miniport
545 * drivers in that case adjust parameters and call VideoPortInitialize
546 * again.
547 */
548 DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
549 if (DriverExtension == NULL)
550 {
551 Status = IoAllocateDriverObjectExtension(DriverObject,
552 DriverObject,
553 sizeof(VIDEO_PORT_DRIVER_EXTENSION),
554 (PVOID *)&DriverExtension);
555 if (!NT_SUCCESS(Status))
556 {
557 ERR_(VIDEOPRT, "IoAllocateDriverObjectExtension failed 0x%x\n", Status);
558 return Status;
559 }
560
561 /*
562 * Save the registry path. This should be done only once even if
563 * VideoPortInitialize is called multiple times.
564 */
565 if (RegistryPath->Length != 0)
566 {
567 DriverExtension->RegistryPath.Length = 0;
568 DriverExtension->RegistryPath.MaximumLength =
569 RegistryPath->Length + sizeof(UNICODE_NULL);
570 DriverExtension->RegistryPath.Buffer =
571 ExAllocatePoolWithTag(
572 PagedPool,
573 DriverExtension->RegistryPath.MaximumLength,
574 'RTSU');
575 if (DriverExtension->RegistryPath.Buffer == NULL)
576 {
577 RtlInitUnicodeString(&DriverExtension->RegistryPath, NULL);
578 return STATUS_INSUFFICIENT_RESOURCES;
579 }
580
581 RtlCopyUnicodeString(&DriverExtension->RegistryPath, RegistryPath);
582 INFO_(VIDEOPRT, "RegistryPath: %wZ\n", &DriverExtension->RegistryPath);
583 }
584 else
585 {
586 RtlInitUnicodeString(&DriverExtension->RegistryPath, NULL);
587 }
588 }
589
590 /* Copy the correct miniport initialization data to the device extension. */
591 RtlCopyMemory(&DriverExtension->InitializationData,
592 HwInitializationData,
593 HwInitializationData->HwInitDataSize);
594 if (HwInitializationData->HwInitDataSize <
595 sizeof(VIDEO_HW_INITIALIZATION_DATA))
596 {
597 RtlZeroMemory((PVOID)((ULONG_PTR)&DriverExtension->InitializationData +
598 HwInitializationData->HwInitDataSize),
599 sizeof(VIDEO_HW_INITIALIZATION_DATA) -
600 HwInitializationData->HwInitDataSize);
601 }
602 DriverExtension->HwContext = HwContext;
603
604 /*
605 * Plug & Play drivers registers the device in AddDevice routine. For
606 * legacy drivers we must do it now.
607 */
608 if (LegacyDetection)
609 {
610 PDEVICE_OBJECT DeviceObject;
611
612 if (HwInitializationData->HwInitDataSize != SIZE_OF_NT4_VIDEO_HW_INITIALIZATION_DATA)
613 {
614 /* power management */
615 DriverObject->MajorFunction[IRP_MJ_POWER] = IntVideoPortDispatchPower;
616 }
617
618 Status = IntVideoPortCreateAdapterDeviceObject(DriverObject,
619 DriverExtension,
620 NULL,
621 &DeviceObject);
622 if (!NT_SUCCESS(Status))
623 {
624 ERR_(VIDEOPRT, "IntVideoPortCreateAdapterDeviceObject returned 0x%x\n", Status);
625 return Status;
626 }
627
628 Status = IntVideoPortFindAdapter(DriverObject, DriverExtension, DeviceObject);
629 if (NT_SUCCESS(Status))
630 VideoPortDeviceNumber++;
631 else
632 ERR_(VIDEOPRT, "IntVideoPortFindAdapter returned 0x%x\n", Status);
633
634 return Status;
635 }
636 else
637 {
638 DriverObject->DriverExtension->AddDevice = IntVideoPortAddDevice;
639 DriverObject->MajorFunction[IRP_MJ_PNP] = IntVideoPortDispatchPnp;
640 DriverObject->MajorFunction[IRP_MJ_POWER] = IntVideoPortDispatchPower;
641 DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = IntVideoPortDispatchSystemControl;
642
643 return STATUS_SUCCESS;
644 }
645 }
646
647 /*
648 * @implemented
649 */
650 VOID
651 VideoPortDebugPrint(
652 IN VIDEO_DEBUG_LEVEL DebugPrintLevel,
653 IN PCHAR DebugMessage,
654 ...)
655 {
656 va_list ap;
657
658 va_start(ap, DebugMessage);
659 vDbgPrintEx(DPFLTR_IHVVIDEO_ID, DebugPrintLevel, DebugMessage, ap);
660 va_end(ap);
661 }
662
663 /*
664 * @unimplemented
665 */
666 VOID
667 NTAPI
668 VideoPortLogError(
669 IN PVOID HwDeviceExtension,
670 IN PVIDEO_REQUEST_PACKET Vrp OPTIONAL,
671 IN VP_STATUS ErrorCode,
672 IN ULONG UniqueId)
673 {
674 UNIMPLEMENTED;
675
676 INFO_(VIDEOPRT, "VideoPortLogError ErrorCode %d (0x%x) UniqueId %lu (0x%lx)\n",
677 ErrorCode, ErrorCode, UniqueId, UniqueId);
678 if (Vrp)
679 INFO_(VIDEOPRT, "Vrp->IoControlCode %lu (0x%lx)\n", Vrp->IoControlCode, Vrp->IoControlCode);
680 }
681
682 /*
683 * @implemented
684 */
685 UCHAR
686 NTAPI
687 VideoPortGetCurrentIrql(VOID)
688 {
689 return KeGetCurrentIrql();
690 }
691
692 typedef struct QueryRegistryCallbackContext
693 {
694 PVOID HwDeviceExtension;
695 PVOID HwContext;
696 PMINIPORT_GET_REGISTRY_ROUTINE HwGetRegistryRoutine;
697 } QUERY_REGISTRY_CALLBACK_CONTEXT, *PQUERY_REGISTRY_CALLBACK_CONTEXT;
698
699 static
700 NTSTATUS
701 NTAPI
702 QueryRegistryCallback(
703 IN PWSTR ValueName,
704 IN ULONG ValueType,
705 IN PVOID ValueData,
706 IN ULONG ValueLength,
707 IN PVOID Context,
708 IN PVOID EntryContext)
709 {
710 PQUERY_REGISTRY_CALLBACK_CONTEXT CallbackContext = (PQUERY_REGISTRY_CALLBACK_CONTEXT) Context;
711
712 INFO_(VIDEOPRT, "Found registry value for name %S: type %d, length %d\n",
713 ValueName, ValueType, ValueLength);
714 return (*(CallbackContext->HwGetRegistryRoutine))(
715 CallbackContext->HwDeviceExtension,
716 CallbackContext->HwContext,
717 ValueName,
718 ValueData,
719 ValueLength);
720 }
721
722 /*
723 * @unimplemented
724 */
725
726 VP_STATUS
727 NTAPI
728 VideoPortGetRegistryParameters(
729 IN PVOID HwDeviceExtension,
730 IN PWSTR ParameterName,
731 IN UCHAR IsParameterFileName,
732 IN PMINIPORT_GET_REGISTRY_ROUTINE GetRegistryRoutine,
733 IN PVOID HwContext)
734 {
735 RTL_QUERY_REGISTRY_TABLE QueryTable[2] = {{0}};
736 QUERY_REGISTRY_CALLBACK_CONTEXT Context;
737 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
738 NTSTATUS Status;
739
740 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
741
742 TRACE_(VIDEOPRT, "VideoPortGetRegistryParameters ParameterName %S, RegPath: %wZ\n",
743 ParameterName, &DeviceExtension->RegistryPath);
744
745 Context.HwDeviceExtension = HwDeviceExtension;
746 Context.HwContext = HwContext;
747 Context.HwGetRegistryRoutine = GetRegistryRoutine;
748
749 QueryTable[0].QueryRoutine = QueryRegistryCallback;
750 QueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED;
751 QueryTable[0].Name = ParameterName;
752
753 Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
754 DeviceExtension->RegistryPath.Buffer,
755 QueryTable,
756 &Context,
757 NULL);
758 if (!NT_SUCCESS(Status))
759 {
760 WARN_(VIDEOPRT, "VideoPortGetRegistryParameters could not find the "
761 "requested parameter\n");
762 return ERROR_INVALID_PARAMETER;
763 }
764
765 if (IsParameterFileName)
766 {
767 /* FIXME: need to read the contents of the file */
768 UNIMPLEMENTED;
769 }
770
771 return NO_ERROR;
772 }
773
774 /*
775 * @implemented
776 */
777 VP_STATUS
778 NTAPI
779 VideoPortSetRegistryParameters(
780 IN PVOID HwDeviceExtension,
781 IN PWSTR ValueName,
782 IN PVOID ValueData,
783 IN ULONG ValueLength)
784 {
785 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
786 VP_STATUS Status;
787
788 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
789 TRACE_(VIDEOPRT, "VideoPortSetRegistryParameters ParameterName %S, RegPath: %wZ\n",
790 ValueName,
791 &DeviceExtension->RegistryPath);
792 ASSERT_IRQL_LESS_OR_EQUAL(PASSIVE_LEVEL);
793 Status = RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
794 DeviceExtension->RegistryPath.Buffer,
795 ValueName,
796 REG_BINARY,
797 ValueData,
798 ValueLength);
799 if (Status != NO_ERROR)
800 WARN_(VIDEOPRT, "VideoPortSetRegistryParameters error 0x%x\n", Status);
801
802 return Status;
803 }
804
805 /*
806 * @implemented
807 */
808 VP_STATUS
809 NTAPI
810 VideoPortGetVgaStatus(
811 IN PVOID HwDeviceExtension,
812 OUT PULONG VgaStatus)
813 {
814 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
815
816 TRACE_(VIDEOPRT, "VideoPortGetVgaStatus\n");
817
818 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
819 if (KeGetCurrentIrql() == PASSIVE_LEVEL)
820 {
821 if (DeviceExtension->AdapterInterfaceType == PCIBus)
822 {
823 /* VgaStatus: 0 == VGA not enabled, 1 == VGA enabled. */
824 /* Assumed for now */
825 *VgaStatus = 1;
826 return NO_ERROR;
827 }
828 }
829
830 return ERROR_INVALID_FUNCTION;
831 }
832
833 /*
834 * @implemented
835 */
836 PVOID
837 NTAPI
838 VideoPortGetRomImage(
839 IN PVOID HwDeviceExtension,
840 IN PVOID Unused1,
841 IN ULONG Unused2,
842 IN ULONG Length)
843 {
844 static PVOID RomImageBuffer = NULL;
845 PKPROCESS CallingProcess;
846 KAPC_STATE ApcState;
847
848 TRACE_(VIDEOPRT, "VideoPortGetRomImage(HwDeviceExtension 0x%X Length 0x%X)\n",
849 HwDeviceExtension, Length);
850
851 /* If the length is zero then free the existing buffer. */
852 if (Length == 0)
853 {
854 if (RomImageBuffer != NULL)
855 {
856 ExFreePool(RomImageBuffer);
857 RomImageBuffer = NULL;
858 }
859 return NULL;
860 }
861 else
862 {
863 /*
864 * The DDK says we shouldn't use the legacy C0000 method but get the
865 * rom base address from the corresponding pci or acpi register but
866 * lets ignore that and use C0000 anyway. We have already mapped the
867 * bios area into memory so we'll copy from there.
868 */
869
870 /* Copy the bios. */
871 Length = min(Length, 0x10000);
872 if (RomImageBuffer != NULL)
873 {
874 ExFreePool(RomImageBuffer);
875 }
876
877 RomImageBuffer = ExAllocatePool(PagedPool, Length);
878 if (RomImageBuffer == NULL)
879 {
880 return NULL;
881 }
882
883 IntAttachToCSRSS(&CallingProcess, &ApcState);
884 RtlCopyMemory(RomImageBuffer, (PUCHAR)0xC0000, Length);
885 IntDetachFromCSRSS(&CallingProcess, &ApcState);
886
887 return RomImageBuffer;
888 }
889 }
890
891 /*
892 * @implemented
893 */
894 BOOLEAN
895 NTAPI
896 VideoPortScanRom(
897 IN PVOID HwDeviceExtension,
898 IN PUCHAR RomBase,
899 IN ULONG RomLength,
900 IN PUCHAR String)
901 {
902 ULONG StringLength;
903 BOOLEAN Found;
904 PUCHAR SearchLocation;
905
906 TRACE_(VIDEOPRT, "VideoPortScanRom RomBase %p RomLength 0x%x String %s\n", RomBase, RomLength, String);
907
908 StringLength = strlen((PCHAR)String);
909 Found = FALSE;
910 SearchLocation = RomBase;
911 for (SearchLocation = RomBase;
912 !Found && SearchLocation < RomBase + RomLength - StringLength;
913 SearchLocation++)
914 {
915 Found = (RtlCompareMemory(SearchLocation, String, StringLength) == StringLength);
916 if (Found)
917 {
918 INFO_(VIDEOPRT, "Match found at %p\n", SearchLocation);
919 }
920 }
921
922 return Found;
923 }
924
925 /*
926 * @implemented
927 */
928 BOOLEAN
929 NTAPI
930 VideoPortSynchronizeExecution(
931 IN PVOID HwDeviceExtension,
932 IN VIDEO_SYNCHRONIZE_PRIORITY Priority,
933 IN PMINIPORT_SYNCHRONIZE_ROUTINE SynchronizeRoutine,
934 OUT PVOID Context)
935 {
936 BOOLEAN Ret;
937 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
938 KIRQL OldIrql;
939
940 switch (Priority)
941 {
942 case VpLowPriority:
943 Ret = (*SynchronizeRoutine)(Context);
944 break;
945
946 case VpMediumPriority:
947 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
948 if (DeviceExtension->InterruptObject == NULL)
949 Ret = (*SynchronizeRoutine)(Context);
950 else
951 Ret = KeSynchronizeExecution(
952 DeviceExtension->InterruptObject,
953 SynchronizeRoutine,
954 Context);
955 break;
956
957 case VpHighPriority:
958 OldIrql = KeGetCurrentIrql();
959 if (OldIrql < SYNCH_LEVEL)
960 KeRaiseIrql(SYNCH_LEVEL, &OldIrql);
961
962 Ret = (*SynchronizeRoutine)(Context);
963
964 if (OldIrql < SYNCH_LEVEL)
965 KeLowerIrql(OldIrql);
966 break;
967
968 default:
969 Ret = FALSE;
970 }
971
972 return Ret;
973 }
974
975 /*
976 * @implemented
977 */
978 VP_STATUS
979 NTAPI
980 VideoPortEnumerateChildren(
981 IN PVOID HwDeviceExtension,
982 IN PVOID Reserved)
983 {
984 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
985 ULONG Status;
986 VIDEO_CHILD_ENUM_INFO ChildEnumInfo;
987 BOOLEAN bHaveLastMonitorID = FALSE;
988 UCHAR LastMonitorID[10];
989 ULONG Unused;
990 UINT i;
991 PDEVICE_OBJECT ChildDeviceObject;
992 PVIDEO_PORT_CHILD_EXTENSION ChildExtension;
993
994 INFO_(VIDEOPRT, "Starting child device probe\n");
995 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
996 if (DeviceExtension->DriverExtension->InitializationData.HwGetVideoChildDescriptor == NULL)
997 {
998 WARN_(VIDEOPRT, "Miniport's HwGetVideoChildDescriptor is NULL!\n");
999 return NO_ERROR;
1000 }
1001
1002 if (!IsListEmpty(&DeviceExtension->ChildDeviceList))
1003 {
1004 ERR_(VIDEOPRT, "FIXME: Support calling VideoPortEnumerateChildren again!\n");
1005 return NO_ERROR;
1006 }
1007
1008 /* Enumerate the children */
1009 for (i = 1; ; i++)
1010 {
1011 Status = IoCreateDevice(DeviceExtension->DriverObject,
1012 sizeof(VIDEO_PORT_CHILD_EXTENSION) +
1013 DeviceExtension->DriverExtension->InitializationData.HwChildDeviceExtensionSize,
1014 NULL,
1015 FILE_DEVICE_CONTROLLER,
1016 FILE_DEVICE_SECURE_OPEN,
1017 FALSE,
1018 &ChildDeviceObject);
1019 if (!NT_SUCCESS(Status))
1020 return Status;
1021
1022 ChildExtension = ChildDeviceObject->DeviceExtension;
1023
1024 RtlZeroMemory(ChildExtension,
1025 sizeof(VIDEO_PORT_CHILD_EXTENSION) +
1026 DeviceExtension->DriverExtension->InitializationData.HwChildDeviceExtensionSize);
1027
1028 ChildExtension->Common.Fdo = FALSE;
1029 ChildExtension->ChildId = i;
1030 ChildExtension->PhysicalDeviceObject = ChildDeviceObject;
1031 ChildExtension->DriverObject = DeviceExtension->DriverObject;
1032
1033 /* Setup the ChildEnumInfo */
1034 ChildEnumInfo.Size = sizeof(ChildEnumInfo);
1035 ChildEnumInfo.ChildDescriptorSize = sizeof(ChildExtension->ChildDescriptor);
1036 ChildEnumInfo.ACPIHwId = 0;
1037
1038 if (DeviceExtension->DriverExtension->InitializationData.HwChildDeviceExtensionSize)
1039 ChildEnumInfo.ChildHwDeviceExtension = VIDEO_PORT_GET_CHILD_EXTENSION(ChildExtension);
1040 else
1041 ChildEnumInfo.ChildHwDeviceExtension = NULL;
1042
1043 ChildEnumInfo.ChildIndex = ChildExtension->ChildId;
1044
1045 INFO_(VIDEOPRT, "Probing child: %d\n", ChildEnumInfo.ChildIndex);
1046 Status = DeviceExtension->DriverExtension->InitializationData.HwGetVideoChildDescriptor(
1047 HwDeviceExtension,
1048 &ChildEnumInfo,
1049 &ChildExtension->ChildType,
1050 ChildExtension->ChildDescriptor,
1051 &ChildExtension->ChildId,
1052 &Unused);
1053 if (Status == VIDEO_ENUM_MORE_DEVICES)
1054 {
1055 if (ChildExtension->ChildType == Monitor)
1056 {
1057 // Check if the EDID is valid
1058 if (ChildExtension->ChildDescriptor[0] == 0x00 &&
1059 ChildExtension->ChildDescriptor[1] == 0xFF &&
1060 ChildExtension->ChildDescriptor[2] == 0xFF &&
1061 ChildExtension->ChildDescriptor[3] == 0xFF &&
1062 ChildExtension->ChildDescriptor[4] == 0xFF &&
1063 ChildExtension->ChildDescriptor[5] == 0xFF &&
1064 ChildExtension->ChildDescriptor[6] == 0xFF &&
1065 ChildExtension->ChildDescriptor[7] == 0x00)
1066 {
1067 if (bHaveLastMonitorID)
1068 {
1069 // Compare the previous monitor ID with the current one, break the loop if they are identical
1070 if (RtlCompareMemory(LastMonitorID, &ChildExtension->ChildDescriptor[8], sizeof(LastMonitorID)) == sizeof(LastMonitorID))
1071 {
1072 INFO_(VIDEOPRT, "Found identical Monitor ID two times, stopping enumeration\n");
1073 IoDeleteDevice(ChildDeviceObject);
1074 break;
1075 }
1076 }
1077
1078 // Copy 10 bytes from the EDID, which can be used to uniquely identify the monitor
1079 RtlCopyMemory(LastMonitorID, &ChildExtension->ChildDescriptor[8], sizeof(LastMonitorID));
1080 bHaveLastMonitorID = TRUE;
1081
1082 /* Mark it valid */
1083 ChildExtension->EdidValid = TRUE;
1084 }
1085 else
1086 {
1087 /* Mark it invalid */
1088 ChildExtension->EdidValid = FALSE;
1089 }
1090 }
1091 }
1092 else if (Status == VIDEO_ENUM_INVALID_DEVICE)
1093 {
1094 WARN_(VIDEOPRT, "Child device %d is invalid!\n", ChildEnumInfo.ChildIndex);
1095 IoDeleteDevice(ChildDeviceObject);
1096 continue;
1097 }
1098 else if (Status == VIDEO_ENUM_NO_MORE_DEVICES)
1099 {
1100 INFO_(VIDEOPRT, "End of child enumeration! (%d children enumerated)\n", i - 1);
1101 IoDeleteDevice(ChildDeviceObject);
1102 break;
1103 }
1104 else
1105 {
1106 WARN_(VIDEOPRT, "HwGetVideoChildDescriptor returned unknown status code 0x%x!\n", Status);
1107 IoDeleteDevice(ChildDeviceObject);
1108 break;
1109 }
1110
1111 if (ChildExtension->ChildType == Monitor)
1112 {
1113 UINT j;
1114 PUCHAR p = ChildExtension->ChildDescriptor;
1115 INFO_(VIDEOPRT, "Monitor device enumerated! (ChildId = 0x%x)\n", ChildExtension->ChildId);
1116 for (j = 0; j < sizeof (ChildExtension->ChildDescriptor); j += 8)
1117 {
1118 INFO_(VIDEOPRT, "%02x %02x %02x %02x %02x %02x %02x %02x\n",
1119 p[j + 0], p[j + 1], p[j + 2], p[j + 3],
1120 p[j + 4], p[j + 5], p[j + 6], p[j + 7]);
1121 }
1122 }
1123 else if (ChildExtension->ChildType == Other)
1124 {
1125 INFO_(VIDEOPRT, "\"Other\" device enumerated: DeviceId = %S\n", (PWSTR)ChildExtension->ChildDescriptor);
1126 }
1127 else
1128 {
1129 ERR_(VIDEOPRT, "HwGetVideoChildDescriptor returned unsupported type: %d\n", ChildExtension->ChildType);
1130 }
1131
1132 /* Clear the init flag */
1133 ChildDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
1134
1135 InsertTailList(&DeviceExtension->ChildDeviceList,
1136 &ChildExtension->ListEntry);
1137 }
1138
1139 /* Trigger reenumeration by the PnP manager */
1140 IoInvalidateDeviceRelations(DeviceExtension->PhysicalDeviceObject, BusRelations);
1141
1142 return NO_ERROR;
1143 }
1144
1145 /*
1146 * @unimplemented
1147 */
1148 VP_STATUS
1149 NTAPI
1150 VideoPortCreateSecondaryDisplay(
1151 IN PVOID HwDeviceExtension,
1152 IN OUT PVOID *SecondaryDeviceExtension,
1153 IN ULONG Flag)
1154 {
1155 UNIMPLEMENTED;
1156 return ERROR_DEV_NOT_EXIST;
1157 }
1158
1159 /*
1160 * @implemented
1161 */
1162 BOOLEAN
1163 NTAPI
1164 VideoPortQueueDpc(
1165 IN PVOID HwDeviceExtension,
1166 IN PMINIPORT_DPC_ROUTINE CallbackRoutine,
1167 IN PVOID Context)
1168 {
1169 return KeInsertQueueDpc(
1170 &VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension)->DpcObject,
1171 (PVOID)CallbackRoutine,
1172 (PVOID)Context);
1173 }
1174
1175 /*
1176 * @implemented
1177 */
1178 PVOID
1179 NTAPI
1180 VideoPortGetAssociatedDeviceExtension(
1181 IN PVOID DeviceObject)
1182 {
1183 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1184
1185 TRACE_(VIDEOPRT, "VideoPortGetAssociatedDeviceExtension\n");
1186 DeviceExtension = ((PDEVICE_OBJECT)DeviceObject)->DeviceExtension;
1187 if (!DeviceExtension)
1188 return NULL;
1189 return DeviceExtension->MiniPortDeviceExtension;
1190 }
1191
1192 /*
1193 * @implemented
1194 */
1195 VP_STATUS
1196 NTAPI
1197 VideoPortGetVersion(
1198 IN PVOID HwDeviceExtension,
1199 IN OUT PVPOSVERSIONINFO VpOsVersionInfo)
1200 {
1201 RTL_OSVERSIONINFOEXW Version;
1202
1203 Version.dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW);
1204 if (VpOsVersionInfo->Size >= sizeof(VPOSVERSIONINFO))
1205 {
1206 #if 1
1207 if (NT_SUCCESS(RtlGetVersion((PRTL_OSVERSIONINFOW)&Version)))
1208 {
1209 VpOsVersionInfo->MajorVersion = Version.dwMajorVersion;
1210 VpOsVersionInfo->MinorVersion = Version.dwMinorVersion;
1211 VpOsVersionInfo->BuildNumber = Version.dwBuildNumber;
1212 VpOsVersionInfo->ServicePackMajor = Version.wServicePackMajor;
1213 VpOsVersionInfo->ServicePackMinor = Version.wServicePackMinor;
1214 return NO_ERROR;
1215 }
1216 return ERROR_INVALID_PARAMETER;
1217 #else
1218 VpOsVersionInfo->MajorVersion = 5;
1219 VpOsVersionInfo->MinorVersion = 0;
1220 VpOsVersionInfo->BuildNumber = 2195;
1221 VpOsVersionInfo->ServicePackMajor = 4;
1222 VpOsVersionInfo->ServicePackMinor = 0;
1223 return NO_ERROR;
1224 #endif
1225 }
1226
1227 return ERROR_INVALID_PARAMETER;
1228 }
1229
1230 /*
1231 * @implemented
1232 */
1233 BOOLEAN
1234 NTAPI
1235 VideoPortCheckForDeviceExistence(
1236 IN PVOID HwDeviceExtension,
1237 IN USHORT VendorId,
1238 IN USHORT DeviceId,
1239 IN UCHAR RevisionId,
1240 IN USHORT SubVendorId,
1241 IN USHORT SubSystemId,
1242 IN ULONG Flags)
1243 {
1244 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1245 PCI_DEVICE_PRESENT_INTERFACE PciDevicePresentInterface;
1246 IO_STATUS_BLOCK IoStatusBlock;
1247 IO_STACK_LOCATION IoStack;
1248 ULONG PciFlags = 0;
1249 NTSTATUS Status;
1250 BOOL DevicePresent;
1251
1252 TRACE_(VIDEOPRT, "VideoPortCheckForDeviceExistence\n");
1253
1254 if (Flags & ~(CDE_USE_REVISION | CDE_USE_SUBSYSTEM_IDS))
1255 {
1256 WARN_(VIDEOPRT, "VideoPortCheckForDeviceExistence: Unknown flags 0x%lx\n", Flags & ~(CDE_USE_REVISION | CDE_USE_SUBSYSTEM_IDS));
1257 return FALSE;
1258 }
1259
1260 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
1261
1262 PciDevicePresentInterface.Size = sizeof(PCI_DEVICE_PRESENT_INTERFACE);
1263 PciDevicePresentInterface.Version = 1;
1264 IoStack.Parameters.QueryInterface.Size = PciDevicePresentInterface.Size;
1265 IoStack.Parameters.QueryInterface.Version = PciDevicePresentInterface.Version;
1266 IoStack.Parameters.QueryInterface.Interface = (PINTERFACE)&PciDevicePresentInterface;
1267 IoStack.Parameters.QueryInterface.InterfaceType =
1268 &GUID_PCI_DEVICE_PRESENT_INTERFACE;
1269 Status = IopInitiatePnpIrp(DeviceExtension->NextDeviceObject,
1270 &IoStatusBlock, IRP_MN_QUERY_INTERFACE, &IoStack);
1271 if (!NT_SUCCESS(Status))
1272 {
1273 WARN_(VIDEOPRT, "IopInitiatePnpIrp() failed! (Status 0x%lx)\n", Status);
1274 return FALSE;
1275 }
1276
1277 if (Flags & CDE_USE_REVISION)
1278 PciFlags |= PCI_USE_REVISION;
1279 if (Flags & CDE_USE_SUBSYSTEM_IDS)
1280 PciFlags |= PCI_USE_SUBSYSTEM_IDS;
1281
1282 DevicePresent = PciDevicePresentInterface.IsDevicePresent(
1283 VendorId, DeviceId, RevisionId,
1284 SubVendorId, SubSystemId, PciFlags);
1285
1286 PciDevicePresentInterface.InterfaceDereference(PciDevicePresentInterface.Context);
1287
1288 return DevicePresent;
1289 }
1290
1291 /*
1292 * @unimplemented
1293 */
1294 VP_STATUS
1295 NTAPI
1296 VideoPortRegisterBugcheckCallback(
1297 IN PVOID HwDeviceExtension,
1298 IN ULONG BugcheckCode,
1299 IN PVIDEO_BUGCHECK_CALLBACK Callback,
1300 IN ULONG BugcheckDataSize)
1301 {
1302 UNIMPLEMENTED;
1303 return NO_ERROR;
1304 }
1305
1306 /*
1307 * @implemented
1308 */
1309 LONGLONG
1310 NTAPI
1311 VideoPortQueryPerformanceCounter(
1312 IN PVOID HwDeviceExtension,
1313 OUT PLONGLONG PerformanceFrequency OPTIONAL)
1314 {
1315 LARGE_INTEGER Result;
1316
1317 TRACE_(VIDEOPRT, "VideoPortQueryPerformanceCounter\n");
1318 Result = KeQueryPerformanceCounter((PLARGE_INTEGER)PerformanceFrequency);
1319 return Result.QuadPart;
1320 }
1321
1322 /*
1323 * @implemented
1324 */
1325 VOID
1326 NTAPI
1327 VideoPortAcquireDeviceLock(
1328 IN PVOID HwDeviceExtension)
1329 {
1330 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1331 NTSTATUS Status;
1332 (void)Status;
1333
1334 TRACE_(VIDEOPRT, "VideoPortAcquireDeviceLock\n");
1335 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
1336 Status = KeWaitForMutexObject(&DeviceExtension->DeviceLock, Executive,
1337 KernelMode, FALSE, NULL);
1338 // ASSERT(Status == STATUS_SUCCESS);
1339 }
1340
1341 /*
1342 * @implemented
1343 */
1344 VOID
1345 NTAPI
1346 VideoPortReleaseDeviceLock(
1347 IN PVOID HwDeviceExtension)
1348 {
1349 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1350 LONG Status;
1351 (void)Status;
1352
1353 TRACE_(VIDEOPRT, "VideoPortReleaseDeviceLock\n");
1354 DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
1355 Status = KeReleaseMutex(&DeviceExtension->DeviceLock, FALSE);
1356 //ASSERT(Status == STATUS_SUCCESS);
1357 }
1358
1359 /*
1360 * @unimplemented
1361 */
1362 VOID
1363 NTAPI
1364 VpNotifyEaData(
1365 IN PDEVICE_OBJECT DeviceObject,
1366 IN PVOID Data)
1367 {
1368 UNIMPLEMENTED;
1369 }
1370
1371 /*
1372 * @implemented
1373 */
1374 PVOID
1375 NTAPI
1376 VideoPortAllocateContiguousMemory(
1377 IN PVOID HwDeviceExtension,
1378 IN ULONG NumberOfBytes,
1379 IN PHYSICAL_ADDRESS HighestAcceptableAddress
1380 )
1381 {
1382
1383 return MmAllocateContiguousMemory(NumberOfBytes, HighestAcceptableAddress);
1384 }
1385
1386 /*
1387 * @implemented
1388 */
1389 BOOLEAN
1390 NTAPI
1391 VideoPortIsNoVesa(VOID)
1392 {
1393 NTSTATUS Status;
1394 HANDLE KeyHandle;
1395 UNICODE_STRING Path = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Control");
1396 UNICODE_STRING ValueName = RTL_CONSTANT_STRING(L"SystemStartOptions");
1397 OBJECT_ATTRIBUTES ObjectAttributes;
1398 PKEY_VALUE_PARTIAL_INFORMATION KeyInfo;
1399 ULONG Length, NewLength;
1400
1401 /* Initialize object attributes with the path we want */
1402 InitializeObjectAttributes(&ObjectAttributes,
1403 &Path,
1404 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
1405 NULL,
1406 NULL);
1407
1408 /* Open the key */
1409 Status = ZwOpenKey(&KeyHandle,
1410 KEY_QUERY_VALUE,
1411 &ObjectAttributes);
1412
1413 if (!NT_SUCCESS(Status))
1414 {
1415 VideoPortDebugPrint(Error, "ZwOpenKey failed (0x%x)\n", Status);
1416 return FALSE;
1417 }
1418
1419 /* Find out how large our buffer should be */
1420 Status = ZwQueryValueKey(KeyHandle,
1421 &ValueName,
1422 KeyValuePartialInformation,
1423 NULL,
1424 0,
1425 &Length);
1426 if (Status != STATUS_BUFFER_OVERFLOW && Status != STATUS_BUFFER_TOO_SMALL)
1427 {
1428 VideoPortDebugPrint(Error, "ZwQueryValueKey failed (0x%x)\n", Status);
1429 ZwClose(KeyHandle);
1430 return FALSE;
1431 }
1432
1433 /* Allocate it */
1434 KeyInfo = ExAllocatePool(PagedPool, Length);
1435 if (!KeyInfo)
1436 {
1437 VideoPortDebugPrint(Error, "Out of memory\n");
1438 ZwClose(KeyHandle);
1439 return FALSE;
1440 }
1441
1442 /* Now for real this time */
1443 Status = ZwQueryValueKey(KeyHandle,
1444 &ValueName,
1445 KeyValuePartialInformation,
1446 KeyInfo,
1447 Length,
1448 &NewLength);
1449
1450 ZwClose(KeyHandle);
1451
1452 if (!NT_SUCCESS(Status))
1453 {
1454 VideoPortDebugPrint(Error, "ZwQueryValueKey failed (0x%x)\n", Status);
1455 ExFreePool(KeyInfo);
1456 return FALSE;
1457 }
1458
1459 /* Sanity check */
1460 if (KeyInfo->Type != REG_SZ)
1461 {
1462 VideoPortDebugPrint(Error, "Invalid type for SystemStartOptions\n");
1463 ExFreePool(KeyInfo);
1464 return FALSE;
1465 }
1466
1467 /* Check if NOVESA or BASEVIDEO is present in the start options */
1468 if (wcsstr((PWCHAR)KeyInfo->Data, L"NOVESA") ||
1469 wcsstr((PWCHAR)KeyInfo->Data, L"BASEVIDEO"))
1470 {
1471 VideoPortDebugPrint(Info, "VESA mode disabled\n");
1472 ExFreePool(KeyInfo);
1473 return TRUE;
1474 }
1475
1476 ExFreePool(KeyInfo);
1477
1478 VideoPortDebugPrint(Info, "VESA mode enabled\n");
1479
1480 return FALSE;
1481 }