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