ReactOS  0.4.15-dev-3718-g2318f7f
videoprt.c
Go to the documentation of this file.
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/obfuncs.h>
27 #include <ndk/rtlfuncs.h>
28 
29 #define NDEBUG
30 #include <debug.h>
31 
32 /* GLOBAL VARIABLES ***********************************************************/
33 
35 
38 
44 
45 /* PRIVATE FUNCTIONS **********************************************************/
46 
47 ULONG
48 NTAPI
52 {
53  return STATUS_SUCCESS;
54 }
55 
56 static
59  PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension)
60 {
61  WCHAR DeviceBuffer[20];
63  WCHAR SymlinkBuffer[20];
64  UNICODE_STRING SymlinkName;
67 
68  /* Create a unicode device name. */
69  DeviceNumber = DeviceExtension->DeviceNumber;
70  swprintf(DeviceBuffer, L"\\Device\\Video%lu", DeviceNumber);
71 
72  /* Add entry to DEVICEMAP\VIDEO key in registry. */
74  L"VIDEO",
75  DeviceBuffer,
76  REG_SZ,
77  DeviceExtension->NewRegistryPath.Buffer,
78  DeviceExtension->NewRegistryPath.Length + sizeof(UNICODE_NULL));
79  if (!NT_SUCCESS(Status))
80  {
81  ERR_(VIDEOPRT, "Failed to create DEViCEMAP registry entry: 0x%X\n", Status);
82  return Status;
83  }
84 
86  L"VIDEO",
87  L"MaxObjectNumber",
88  REG_DWORD,
89  &DeviceNumber,
90  sizeof(DeviceNumber));
91  if (!NT_SUCCESS(Status))
92  {
93  ERR_(VIDEOPRT, "Failed to write MaxObjectNumber: 0x%X\n", Status);
94  return Status;
95  }
96 
97  /* Create symbolic link "\??\DISPLAYx" */
98  swprintf(SymlinkBuffer, L"\\??\\DISPLAY%lu", DeviceNumber + 1);
99  RtlInitUnicodeString(&SymlinkName, SymlinkBuffer);
100  RtlInitUnicodeString(&DeviceName, DeviceBuffer);
101  Status = IoCreateSymbolicLink(&SymlinkName, &DeviceName);
102  if (!NT_SUCCESS(Status))
103  {
104  ERR_(VIDEOPRT, "Failed to create symbolic link: 0x%X\n", Status);
105  return Status;
106  }
107 
108  /* Update MaxObjectNumber */
110 
111  return STATUS_SUCCESS;
112 }
113 
114 PVOID
115 NTAPI
119 {
120  PIMAGE_NT_HEADERS NtHeader;
121  ULONG Va;
122 
123  NtHeader = RtlImageNtHeader(BaseAddress);
124  if (NtHeader == NULL)
125  return NULL;
126 
128  return NULL;
129 
131  if (Va == 0)
132  return NULL;
133 
134  return (PVOID)((ULONG_PTR)BaseAddress + Va);
135 }
136 
137 VOID
138 NTAPI
140  IN PKDPC Dpc,
144 {
145  PVOID HwDeviceExtension =
146  &((PVIDEO_PORT_DEVICE_EXTENSION)DeferredContext)->MiniPortDeviceExtension;
148 }
149 
150 NTSTATUS
151 NTAPI
156  _In_ USHORT AdapterNumber,
157  _In_ USHORT DisplayNumber,
159 {
160  PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
162  ULONG PciSlotNumber;
164  ULONG Size;
166  WCHAR DeviceBuffer[20];
168  PDEVICE_OBJECT DeviceObject_;
169 
170  if (DeviceObject == NULL)
171  DeviceObject = &DeviceObject_;
172 
173  /*
174  * Find the first free device number that can be used for video device
175  * object names and symlinks.
176  */
178  if (DeviceNumber == (ULONG)-1)
179  {
180  WARN_(VIDEOPRT, "Can't find free device number\n");
181  return STATUS_UNSUCCESSFUL;
182  }
183 
184  /*
185  * Create the device object.
186  */
187 
188  /* Create a unicode device name. */
189  swprintf(DeviceBuffer, L"\\Device\\Video%lu", DeviceNumber);
190  RtlInitUnicodeString(&DeviceName, DeviceBuffer);
191 
192  INFO_(VIDEOPRT, "HwDeviceExtension size is: 0x%x\n",
193  DriverExtension->InitializationData.HwDeviceExtensionSize);
194 
195  /* Create the device object. */
197  DriverExtension->InitializationData.HwDeviceExtensionSize;
199  Size,
200  &DeviceName,
202  0,
203  TRUE,
204  DeviceObject);
205 
206  if (!NT_SUCCESS(Status))
207  {
208  WARN_(VIDEOPRT, "IoCreateDevice call failed with status 0x%08x\n", Status);
209  return Status;
210  }
211 
212  /*
213  * Set the buffering strategy here. If you change this, remember
214  * to change VidDispatchDeviceControl too.
215  */
216 
217  (*DeviceObject)->Flags |= DO_BUFFERED_IO;
218 
219  /* Initialize device extension. */
220  DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)((*DeviceObject)->DeviceExtension);
221  DeviceExtension->Common.Fdo = TRUE;
222  DeviceExtension->DeviceNumber = DeviceNumber;
223  DeviceExtension->DriverObject = DriverObject;
224  DeviceExtension->PhysicalDeviceObject = PhysicalDeviceObject;
225  DeviceExtension->FunctionalDeviceObject = *DeviceObject;
226  DeviceExtension->DriverExtension = DriverExtension;
227  DeviceExtension->SessionId = -1;
228  DeviceExtension->AdapterNumber = AdapterNumber;
229  DeviceExtension->DisplayNumber = DisplayNumber;
230 
231  InitializeListHead(&DeviceExtension->ChildDeviceList);
232 
233  /* Get the registry path associated with this device. */
235  DeviceExtension->AdapterNumber,
236  &DeviceExtension->RegistryPath);
237  if (!NT_SUCCESS(Status))
238  {
239  WARN_(VIDEOPRT, "IntCreateRegistryPath() call failed with status 0x%08x\n", Status);
241  *DeviceObject = NULL;
242  return Status;
243  }
244 
245  if (PhysicalDeviceObject != NULL)
246  {
247  /* Get bus number from the upper level bus driver. */
248  Size = sizeof(ULONG);
251  Size,
252  &DeviceExtension->SystemIoBusNumber,
253  &Size);
254  if (!NT_SUCCESS(Status))
255  {
256  WARN_(VIDEOPRT, "Couldn't get an information from bus driver. We will try to\n"
257  "use legacy detection method, but even that doesn't mean that\n"
258  "it will work.\n");
259  DeviceExtension->PhysicalDeviceObject = NULL;
260  }
261  }
262 
263  DeviceExtension->AdapterInterfaceType =
264  DriverExtension->InitializationData.AdapterInterfaceType;
265 
266  if (PhysicalDeviceObject != NULL)
267  {
268  /* Get bus type from the upper level bus driver. */
269  Size = sizeof(ULONG);
272  Size,
273  &DeviceExtension->AdapterInterfaceType,
274  &Size);
275 
276  /* Get bus device address from the upper level bus driver. */
277  Size = sizeof(ULONG);
280  Size,
281  &PciSlotNumber,
282  &Size);
283 
284  /* Convert slotnumber to PCI_SLOT_NUMBER */
285  SlotNumber.u.AsULONG = 0;
286  SlotNumber.u.bits.DeviceNumber = (PciSlotNumber >> 16) & 0xFFFF;
287  SlotNumber.u.bits.FunctionNumber = PciSlotNumber & 0xFFFF;
288  DeviceExtension->SystemIoSlotNumber = SlotNumber.u.AsULONG;
289  }
290 
291  InitializeListHead(&DeviceExtension->AddressMappingListHead);
292  InitializeListHead(&DeviceExtension->DmaAdapterList);
293 
294  KeInitializeDpc(&DeviceExtension->DpcObject,
296  DeviceExtension);
297 
298  KeInitializeMutex(&DeviceExtension->DeviceLock, 0);
299 
300  /* Attach the device. */
301  if ((PhysicalDeviceObject != NULL) && (DisplayNumber == 0))
303  *DeviceObject,
305 
306  Status = IntCreateNewRegistryPath(DeviceExtension);
307  if (!NT_SUCCESS(Status))
308  {
309  ERR_(VIDEOPRT, "IntCreateNewRegistryPath() failed with status 0x%08x\n", Status);
311  *DeviceObject = NULL;
312  return Status;
313  }
314 
315  IntSetupDeviceSettingsKey(DeviceExtension);
316 
317  /* Remove the initailizing flag */
318  (*DeviceObject)->Flags &= ~DO_DEVICE_INITIALIZING;
319 
320  /* Set up the VIDEO/DEVICEMAP registry keys */
321  Status = IntVideoPortAddDeviceMapLink(DeviceExtension);
322  if (!NT_SUCCESS(Status))
323  {
324  ERR_(VIDEOPRT, "IntVideoPortAddDeviceMapLink() failed with status 0x%08x\n", Status);
326  *DeviceObject = NULL;
327  return Status;
328  }
329 
330  if (DisplayNumber == 0)
331  {
332  DriverExtension->InitializationData.StartingDeviceNumber++;
333  }
334 
335  return STATUS_SUCCESS;
336 }
337 
338 
339 NTSTATUS
340 NTAPI
345 {
346  PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
348  VP_STATUS vpStatus;
349  VIDEO_PORT_CONFIG_INFO ConfigInfo;
351  UCHAR Again = FALSE;
352  BOOL LegacyDetection = FALSE;
353 
354  DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
355 
356  /* Setup a ConfigInfo structure that we will pass to HwFindAdapter. */
357  RtlZeroMemory(&ConfigInfo, sizeof(VIDEO_PORT_CONFIG_INFO));
358  ConfigInfo.Length = sizeof(VIDEO_PORT_CONFIG_INFO);
359  ConfigInfo.AdapterInterfaceType = DeviceExtension->AdapterInterfaceType;
360  if (ConfigInfo.AdapterInterfaceType == PCIBus)
361  ConfigInfo.InterruptMode = LevelSensitive;
362  else
363  ConfigInfo.InterruptMode = Latched;
364  ConfigInfo.DriverRegistryPath = DriverExtension->RegistryPath.Buffer;
366  ConfigInfo.SystemIoBusNumber = DeviceExtension->SystemIoBusNumber;
367  ConfigInfo.BusInterruptLevel = DeviceExtension->InterruptLevel;
368  ConfigInfo.BusInterruptVector = DeviceExtension->InterruptVector;
369 
372  sizeof(SystemBasicInfo),
373  NULL);
374  if (NT_SUCCESS(Status))
375  {
378  }
379 
380  // FIXME: Check the adapter key and update VideoDebugLevel variable.
381 
382  /*
383  * Call miniport HwVidFindAdapter entry point to detect if
384  * particular device is present. There are two possible code
385  * paths. The first one is for Legacy drivers (NT4) and cases
386  * when we don't have information about what bus we're on. The
387  * second case is the standard one for Plug & Play drivers.
388  */
389  if (DeviceExtension->PhysicalDeviceObject == NULL)
390  {
391  LegacyDetection = TRUE;
392  }
393 
394  if (LegacyDetection)
395  {
396  ULONG BusNumber, MaxBuses;
397 
398  MaxBuses = DeviceExtension->AdapterInterfaceType == PCIBus ? PCI_MAX_BRIDGE_NUMBER : 1;
399 
400  for (BusNumber = 0; BusNumber < MaxBuses; BusNumber++)
401  {
402  DeviceExtension->SystemIoBusNumber =
403  ConfigInfo.SystemIoBusNumber = BusNumber;
404 
405  RtlZeroMemory(&DeviceExtension->MiniPortDeviceExtension,
406  DriverExtension->InitializationData.HwDeviceExtensionSize);
407 
408  /* FIXME: Need to figure out what string to pass as param 3. */
409  vpStatus = DriverExtension->InitializationData.HwFindAdapter(
410  &DeviceExtension->MiniPortDeviceExtension,
411  DriverExtension->HwContext,
412  NULL,
413  &ConfigInfo,
414  &Again);
415 
416  if (vpStatus == ERROR_DEV_NOT_EXIST)
417  {
418  continue;
419  }
420  else
421  {
422  break;
423  }
424  }
425  }
426  else
427  {
428  /* FIXME: Need to figure out what string to pass as param 3. */
429  vpStatus = DriverExtension->InitializationData.HwFindAdapter(
430  &DeviceExtension->MiniPortDeviceExtension,
431  DriverExtension->HwContext,
432  NULL,
433  &ConfigInfo,
434  &Again);
435  }
436 
437  if (vpStatus != NO_ERROR)
438  {
439  ERR_(VIDEOPRT, "HwFindAdapter call failed with error 0x%X\n", vpStatus);
441  goto Failure;
442  }
443 
444  /*
445  * Now we know the device is present, so let's do all additional tasks
446  * such as creating symlinks or setting up interrupts and timer.
447  */
448 
449  /* FIXME: Allocate hardware resources for device. */
450 
451  /* Allocate interrupt for device. */
453  {
455  goto Failure;
456  }
457 
458  /* Allocate timer for device. */
460  {
461  if (DeviceExtension->InterruptObject != NULL)
462  IoDisconnectInterrupt(DeviceExtension->InterruptObject);
463  ERR_(VIDEOPRT, "IntVideoPortSetupTimer failed\n");
465  goto Failure;
466  }
467 
468  /* If the device can be reset, insert it in the list of resettable adapters */
469  InitializeListHead(&DeviceExtension->HwResetListEntry);
470  if (DriverExtension->InitializationData.HwResetHw != NULL)
471  {
473  &DeviceExtension->HwResetListEntry,
475  }
476 
477  INFO_(VIDEOPRT, "STATUS_SUCCESS\n");
478  return STATUS_SUCCESS;
479 
480 Failure:
481  RtlFreeUnicodeString(&DeviceExtension->RegistryPath);
482  if (DeviceExtension->NextDeviceObject)
483  IoDetachDevice(DeviceExtension->NextDeviceObject);
485  return Status;
486 }
487 
488 VOID
489 FASTCALL
491  PKPROCESS *CallingProcess,
493 {
494  *CallingProcess = (PKPROCESS)PsGetCurrentProcess();
495  if (*CallingProcess != CsrProcess)
496  {
498  }
499 }
500 
501 VOID
502 FASTCALL
504  PKPROCESS *CallingProcess,
506 {
507  if (*CallingProcess != CsrProcess)
508  {
510  }
511 }
512 
513 VOID
514 FASTCALL
516 {
519  UNICODE_STRING Path = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Control");
520  UNICODE_STRING ValueName = RTL_CONSTANT_STRING(L"SystemStartOptions");
524 
525  /* Initialize object attributes with the path we want */
527  &Path,
529  NULL,
530  NULL);
531 
532  /* Open the key */
533  Status = ZwOpenKey(&KeyHandle,
536  if (!NT_SUCCESS(Status))
537  {
538  VideoPortDebugPrint(Error, "ZwOpenKey failed (0x%x)\n", Status);
539  return;
540  }
541 
542  /* Find out how large our buffer should be */
543  Status = ZwQueryValueKey(KeyHandle,
544  &ValueName,
546  NULL,
547  0,
548  &Length);
550  {
551  VideoPortDebugPrint(Error, "ZwQueryValueKey failed (0x%x)\n", Status);
553  return;
554  }
555 
556  /* Allocate it */
558  if (!KeyInfo)
559  {
560  VideoPortDebugPrint(Error, "Out of memory\n");
562  return;
563  }
564 
565  /* Now for real this time */
566  Status = ZwQueryValueKey(KeyHandle,
567  &ValueName,
569  KeyInfo,
570  Length,
571  &NewLength);
573 
574  if (!NT_SUCCESS(Status))
575  {
576  VideoPortDebugPrint(Error, "ZwQueryValueKey failed (0x%x)\n", Status);
578  return;
579  }
580 
581  /* Sanity check */
582  if (KeyInfo->Type != REG_SZ)
583  {
584  VideoPortDebugPrint(Error, "Invalid type for SystemStartOptions\n");
586  return;
587  }
588 
589  /* Check if BASEVIDEO or NOVESA is present in the start options */
590  if (wcsstr((PWCHAR)KeyInfo->Data, L"BASEVIDEO"))
591  VpBaseVideo = TRUE;
592  if (wcsstr((PWCHAR)KeyInfo->Data, L"NOVESA"))
593  VpNoVesa = TRUE;
594 
596 
597  /* FIXME: Old ReactOS-compatibility... */
598  if (VpBaseVideo) VpNoVesa = TRUE;
599 
600  if (VpNoVesa)
601  VideoPortDebugPrint(Info, "VESA mode disabled\n");
602  else
603  VideoPortDebugPrint(Info, "VESA mode enabled\n");
604 
605  /* If we are in BASEVIDEO, create the volatile registry key for Win32k */
606  if (VpBaseVideo)
607  {
608  RtlInitUnicodeString(&Path, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\GraphicsDrivers\\BaseVideo");
609 
611  &Path,
613  NULL,
614  NULL);
615 
616  Status = ZwCreateKey(&KeyHandle,
617  READ_CONTROL, // Non-0 placeholder: no use for this handle.
619  0,
620  NULL,
622  NULL);
623  if (NT_SUCCESS(Status))
625  else
626  ERR_(VIDEOPRT, "Failed to create the BaseVideo key (0x%x)\n", Status);
627  }
628 
629  return;
630 }
631 
632 /* PUBLIC FUNCTIONS ***********************************************************/
633 
634 /*
635  * @implemented
636  */
637 ULONG
638 NTAPI
640  IN PVOID Context1,
641  IN PVOID Context2,
644 {
649  BOOLEAN PnpDriver = FALSE, LegacyDetection = FALSE;
650  static BOOLEAN FirstInitialization;
651 
652  TRACE_(VIDEOPRT, "VideoPortInitialize\n");
653 
654  if (!FirstInitialization)
655  {
656  FirstInitialization = TRUE;
660  }
661 
662  /* As a first thing do parameter checks. */
663  if (HwInitializationData->HwInitDataSize > sizeof(VIDEO_HW_INITIALIZATION_DATA))
664  {
665  ERR_(VIDEOPRT, "Invalid HwInitializationData\n");
667  }
668 
669  if ((HwInitializationData->HwFindAdapter == NULL) ||
670  (HwInitializationData->HwInitialize == NULL) ||
671  (HwInitializationData->HwStartIO == NULL))
672  {
673  ERR_(VIDEOPRT, "Invalid HwInitializationData\n");
675  }
676 
677  switch (HwInitializationData->HwInitDataSize)
678  {
679  /*
680  * NT4 drivers are special case, because we must use legacy method
681  * of detection instead of the Plug & Play one.
682  */
684  INFO_(VIDEOPRT, "We were loaded by a Windows NT miniport driver.\n");
685  break;
686 
688  INFO_(VIDEOPRT, "We were loaded by a Windows 2000 miniport driver.\n");
689  break;
690 
691  case sizeof(VIDEO_HW_INITIALIZATION_DATA):
692  INFO_(VIDEOPRT, "We were loaded by a Windows XP or later miniport driver.\n");
693  break;
694 
695  default:
696  ERR_(VIDEOPRT, "Invalid HwInitializationData size.\n");
697  return STATUS_UNSUCCESSFUL;
698  }
699 
700  /* Set dispatching routines */
703  DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] =
705  DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] =
707  DriverObject->DriverUnload = IntVideoPortUnload;
708 
709  /* Determine type of the miniport driver */
710  if ((HwInitializationData->HwInitDataSize >=
711  FIELD_OFFSET(VIDEO_HW_INITIALIZATION_DATA, HwQueryInterface)) &&
712  (HwInitializationData->HwSetPowerState != NULL) &&
713  (HwInitializationData->HwGetPowerState != NULL) &&
714  (HwInitializationData->HwGetVideoChildDescriptor != NULL))
715  {
716  INFO_(VIDEOPRT, "The miniport is a PnP miniport driver\n");
717  PnpDriver = TRUE;
718  }
719 
720  /* Check if legacy detection should be applied */
721  if (!PnpDriver || HwContext)
722  {
723  INFO_(VIDEOPRT, "Legacy detection for adapter interface %d\n",
724  HwInitializationData->AdapterInterfaceType);
725 
726  /* FIXME: Move the code for legacy detection
727  to another function and call it here */
728  LegacyDetection = TRUE;
729  }
730 
731  /*
732  * NOTE:
733  * The driver extension can be already allocated in case that we were
734  * called by legacy driver and failed detecting device. Some miniport
735  * drivers in that case adjust parameters and call VideoPortInitialize
736  * again.
737  */
739  if (DriverExtension == NULL)
740  {
742  DriverObject,
744  (PVOID *)&DriverExtension);
745  if (!NT_SUCCESS(Status))
746  {
747  ERR_(VIDEOPRT, "IoAllocateDriverObjectExtension failed 0x%x\n", Status);
748  return Status;
749  }
750 
751  /*
752  * Save the registry path. This should be done only once even if
753  * VideoPortInitialize is called multiple times.
754  */
755  if (RegistryPath->Length != 0)
756  {
757  DriverExtension->RegistryPath.Length = 0;
758  DriverExtension->RegistryPath.MaximumLength =
759  RegistryPath->Length + sizeof(UNICODE_NULL);
760  DriverExtension->RegistryPath.Buffer =
762  PagedPool,
763  DriverExtension->RegistryPath.MaximumLength,
764  'RTSU');
765  if (DriverExtension->RegistryPath.Buffer == NULL)
766  {
767  RtlInitUnicodeString(&DriverExtension->RegistryPath, NULL);
769  }
770 
772  INFO_(VIDEOPRT, "RegistryPath: %wZ\n", &DriverExtension->RegistryPath);
773  }
774  else
775  {
776  RtlInitUnicodeString(&DriverExtension->RegistryPath, NULL);
777  }
778  }
779 
780  /* Copy the correct miniport initialization data to the device extension. */
781  RtlCopyMemory(&DriverExtension->InitializationData,
783  HwInitializationData->HwInitDataSize);
784  if (HwInitializationData->HwInitDataSize <
786  {
787  RtlZeroMemory((PVOID)((ULONG_PTR)&DriverExtension->InitializationData +
788  HwInitializationData->HwInitDataSize),
790  HwInitializationData->HwInitDataSize);
791  }
792  DriverExtension->HwContext = HwContext;
793 
794  /*
795  * Plug & Play drivers registers the device in AddDevice routine.
796  * For legacy drivers we must do it now.
797  */
798  if (LegacyDetection)
799  {
801 
803  {
804  /* Power management */
806  }
807 
810  NULL,
811  DriverExtension->InitializationData.StartingDeviceNumber,
812  0,
813  &DeviceObject);
814  if (!NT_SUCCESS(Status))
815  {
816  ERR_(VIDEOPRT, "IntVideoPortCreateAdapterDeviceObject returned 0x%x\n", Status);
817  return Status;
818  }
819 
821  if (!NT_SUCCESS(Status))
822  ERR_(VIDEOPRT, "IntVideoPortFindAdapter returned 0x%x\n", Status);
823 
824  return Status;
825  }
826  else
827  {
828  DriverObject->DriverExtension->AddDevice = IntVideoPortAddDevice;
832 
833  return STATUS_SUCCESS;
834  }
835 }
836 
837 /*
838  * @implemented
839  */
840 VOID
842  IN VIDEO_DEBUG_LEVEL DebugPrintLevel,
843  IN PCHAR DebugMessage,
844  ...)
845 {
846  va_list ap;
847 
848  if (VideoDebugLevel >= DebugPrintLevel)
849  DebugPrintLevel = Error;
850 
851  va_start(ap, DebugMessage);
852  vDbgPrintEx(DPFLTR_IHVVIDEO_ID, DebugPrintLevel, DebugMessage, ap);
853  va_end(ap);
854 }
855 
856 /*
857  * @unimplemented
858  */
859 VOID
860 NTAPI
862  IN PVOID HwDeviceExtension,
865  IN ULONG UniqueId)
866 {
868 
869  INFO_(VIDEOPRT, "VideoPortLogError ErrorCode %d (0x%x) UniqueId %lu (0x%lx)\n",
870  ErrorCode, ErrorCode, UniqueId, UniqueId);
871  if (Vrp)
872  INFO_(VIDEOPRT, "Vrp->IoControlCode %lu (0x%lx)\n", Vrp->IoControlCode, Vrp->IoControlCode);
873 }
874 
875 /*
876  * @implemented
877  */
878 UCHAR
879 NTAPI
881 {
882  return KeGetCurrentIrql();
883 }
884 
886 {
891 
892 static
893 NTSTATUS
894 NTAPI
900  IN PVOID Context,
902 {
904 
905  INFO_(VIDEOPRT, "Found registry value for name %S: type %d, length %d\n",
907  return (*(CallbackContext->HwGetRegistryRoutine))(
908  CallbackContext->HwDeviceExtension,
909  CallbackContext->HwContext,
910  ValueName,
911  ValueData,
912  ValueLength);
913 }
914 
915 /*
916  * @unimplemented
917  */
918 
919 VP_STATUS
920 NTAPI
922  IN PVOID HwDeviceExtension,
924  IN UCHAR IsParameterFileName,
925  IN PMINIPORT_GET_REGISTRY_ROUTINE GetRegistryRoutine,
927 {
930  PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
932 
933  DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
934 
935  TRACE_(VIDEOPRT, "VideoPortGetRegistryParameters ParameterName %S, RegPath: %wZ\n",
936  ParameterName, &DeviceExtension->RegistryPath);
937 
938  Context.HwDeviceExtension = HwDeviceExtension;
939  Context.HwContext = HwContext;
940  Context.HwGetRegistryRoutine = GetRegistryRoutine;
941 
945 
947  DeviceExtension->RegistryPath.Buffer,
948  QueryTable,
949  &Context,
950  NULL);
951  if (!NT_SUCCESS(Status))
952  {
953  WARN_(VIDEOPRT, "VideoPortGetRegistryParameters could not find the "
954  "requested parameter\n");
956  }
957 
958  if (IsParameterFileName)
959  {
960  /* FIXME: need to read the contents of the file */
962  }
963 
964  return NO_ERROR;
965 }
966 
967 /*
968  * @implemented
969  */
970 VP_STATUS
971 NTAPI
973  IN PVOID HwDeviceExtension,
977 {
978  PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
980 
981  DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
982  TRACE_(VIDEOPRT, "VideoPortSetRegistryParameters ParameterName %S, RegPath: %wZ\n",
983  ValueName,
984  &DeviceExtension->RegistryPath);
987  DeviceExtension->RegistryPath.Buffer,
988  ValueName,
989  REG_BINARY,
990  ValueData,
991  ValueLength);
992  if (Status != NO_ERROR)
993  WARN_(VIDEOPRT, "VideoPortSetRegistryParameters error 0x%x\n", Status);
994 
995  return Status;
996 }
997 
998 /*
999  * @implemented
1000  */
1001 VP_STATUS
1002 NTAPI
1004  IN PVOID HwDeviceExtension,
1005  OUT PULONG VgaStatus)
1006 {
1007  PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1008 
1009  TRACE_(VIDEOPRT, "VideoPortGetVgaStatus\n");
1010 
1011  DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
1013  {
1014  if (DeviceExtension->AdapterInterfaceType == PCIBus)
1015  {
1016  /* VgaStatus: 0 == VGA not enabled, 1 == VGA enabled. */
1017  /* Assumed for now */
1018  *VgaStatus = 1;
1019  return NO_ERROR;
1020  }
1021  }
1022 
1023  return ERROR_INVALID_FUNCTION;
1024 }
1025 
1026 /*
1027  * @implemented
1028  */
1029 PVOID
1030 NTAPI
1032  IN PVOID HwDeviceExtension,
1033  IN PVOID Unused1,
1034  IN ULONG Unused2,
1035  IN ULONG Length)
1036 {
1037  static PVOID RomImageBuffer = NULL;
1038  PKPROCESS CallingProcess;
1040 
1041  TRACE_(VIDEOPRT, "VideoPortGetRomImage(HwDeviceExtension 0x%X Length 0x%X)\n",
1042  HwDeviceExtension, Length);
1043 
1044  /* If the length is zero then free the existing buffer. */
1045  if (Length == 0)
1046  {
1047  if (RomImageBuffer != NULL)
1048  {
1049  ExFreePool(RomImageBuffer);
1050  RomImageBuffer = NULL;
1051  }
1052  return NULL;
1053  }
1054  else
1055  {
1056  /*
1057  * The DDK says we shouldn't use the legacy C0000 method but get the
1058  * rom base address from the corresponding pci or acpi register but
1059  * lets ignore that and use C0000 anyway. We have already mapped the
1060  * bios area into memory so we'll copy from there.
1061  */
1062 
1063  /* Copy the bios. */
1064  Length = min(Length, 0x10000);
1065  if (RomImageBuffer != NULL)
1066  {
1067  ExFreePool(RomImageBuffer);
1068  }
1069 
1070  RomImageBuffer = ExAllocatePool(PagedPool, Length);
1071  if (RomImageBuffer == NULL)
1072  {
1073  return NULL;
1074  }
1075 
1076  IntAttachToCSRSS(&CallingProcess, &ApcState);
1077  RtlCopyMemory(RomImageBuffer, (PUCHAR)0xC0000, Length);
1078  IntDetachFromCSRSS(&CallingProcess, &ApcState);
1079 
1080  return RomImageBuffer;
1081  }
1082 }
1083 
1084 /*
1085  * @implemented
1086  */
1087 BOOLEAN
1088 NTAPI
1090  IN PVOID HwDeviceExtension,
1091  IN PUCHAR RomBase,
1092  IN ULONG RomLength,
1093  IN PUCHAR String)
1094 {
1095  SIZE_T StringLength;
1096  BOOLEAN Found;
1097  PUCHAR SearchLocation;
1098 
1099  TRACE_(VIDEOPRT, "VideoPortScanRom RomBase %p RomLength 0x%x String %s\n", RomBase, RomLength, String);
1100 
1101  StringLength = strlen((PCHAR)String);
1102  Found = FALSE;
1103  for (SearchLocation = RomBase;
1104  !Found && SearchLocation < RomBase + RomLength - StringLength;
1105  SearchLocation++)
1106  {
1107  Found = (RtlCompareMemory(SearchLocation, String, StringLength) == StringLength);
1108  if (Found)
1109  {
1110  INFO_(VIDEOPRT, "Match found at %p\n", SearchLocation);
1111  }
1112  }
1113 
1114  return Found;
1115 }
1116 
1117 /*
1118  * @implemented
1119  */
1120 BOOLEAN
1121 NTAPI
1123  IN PVOID HwDeviceExtension,
1126  OUT PVOID Context)
1127 {
1128  BOOLEAN Ret;
1129  PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1130  KIRQL OldIrql;
1131 
1132  switch (Priority)
1133  {
1134  case VpLowPriority:
1135  Ret = (*SynchronizeRoutine)(Context);
1136  break;
1137 
1138  case VpMediumPriority:
1139  DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
1140  if (DeviceExtension->InterruptObject == NULL)
1141  Ret = (*SynchronizeRoutine)(Context);
1142  else
1143  Ret = KeSynchronizeExecution(
1144  DeviceExtension->InterruptObject,
1146  Context);
1147  break;
1148 
1149  case VpHighPriority:
1151  if (OldIrql < SYNCH_LEVEL)
1153 
1154  Ret = (*SynchronizeRoutine)(Context);
1155 
1156  if (OldIrql < SYNCH_LEVEL)
1158  break;
1159 
1160  default:
1161  Ret = FALSE;
1162  }
1163 
1164  return Ret;
1165 }
1166 
1167 /*
1168  * @implemented
1169  */
1173  IN PIRP Irp)
1174 {
1175  PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1176  ULONG Status;
1177  VIDEO_CHILD_ENUM_INFO ChildEnumInfo;
1178  BOOLEAN bHaveLastMonitorID = FALSE;
1179  UCHAR LastMonitorID[10];
1180  ULONG Unused;
1181  UINT i;
1182  PDEVICE_OBJECT ChildDeviceObject;
1183  PVIDEO_PORT_CHILD_EXTENSION ChildExtension;
1184 
1185  INFO_(VIDEOPRT, "Starting child device probe\n");
1186  DeviceExtension = DeviceObject->DeviceExtension;
1188  {
1189  WARN_(VIDEOPRT, "Miniport's HwGetVideoChildDescriptor is NULL!\n");
1190  return STATUS_SUCCESS;
1191  }
1192 
1193  if (!IsListEmpty(&DeviceExtension->ChildDeviceList))
1194  {
1195  ERR_(VIDEOPRT, "FIXME: Support calling VideoPortEnumerateChildren again!\n");
1196  return STATUS_SUCCESS;
1197  }
1198 
1199  /* Enumerate the children */
1200  for (i = 1; ; i++)
1201  {
1202  Status = IoCreateDevice(DeviceExtension->DriverObject,
1203  sizeof(VIDEO_PORT_CHILD_EXTENSION) +
1205  NULL,
1208  FALSE,
1209  &ChildDeviceObject);
1210  if (!NT_SUCCESS(Status))
1211  return Status;
1212 
1213  ChildExtension = ChildDeviceObject->DeviceExtension;
1214 
1215  RtlZeroMemory(ChildExtension,
1216  sizeof(VIDEO_PORT_CHILD_EXTENSION) +
1218 
1219  ChildExtension->Common.Fdo = FALSE;
1220  ChildExtension->ChildId = i;
1221  ChildExtension->PhysicalDeviceObject = ChildDeviceObject;
1222  ChildExtension->DriverObject = DeviceExtension->DriverObject;
1223 
1224  /* Setup the ChildEnumInfo */
1225  ChildEnumInfo.Size = sizeof(ChildEnumInfo);
1226  ChildEnumInfo.ChildDescriptorSize = sizeof(ChildExtension->ChildDescriptor);
1227  ChildEnumInfo.ACPIHwId = 0;
1228 
1230  ChildEnumInfo.ChildHwDeviceExtension = VIDEO_PORT_GET_CHILD_EXTENSION(ChildExtension);
1231  else
1232  ChildEnumInfo.ChildHwDeviceExtension = NULL;
1233 
1234  ChildEnumInfo.ChildIndex = ChildExtension->ChildId;
1235 
1236  INFO_(VIDEOPRT, "Probing child: %d\n", ChildEnumInfo.ChildIndex);
1238  DeviceExtension->MiniPortDeviceExtension,
1239  &ChildEnumInfo,
1240  &ChildExtension->ChildType,
1241  ChildExtension->ChildDescriptor,
1242  &ChildExtension->ChildId,
1243  &Unused);
1245  {
1246  if (ChildExtension->ChildType == Monitor)
1247  {
1248  // Check if the EDID is valid
1249  if (ChildExtension->ChildDescriptor[0] == 0x00 &&
1250  ChildExtension->ChildDescriptor[1] == 0xFF &&
1251  ChildExtension->ChildDescriptor[2] == 0xFF &&
1252  ChildExtension->ChildDescriptor[3] == 0xFF &&
1253  ChildExtension->ChildDescriptor[4] == 0xFF &&
1254  ChildExtension->ChildDescriptor[5] == 0xFF &&
1255  ChildExtension->ChildDescriptor[6] == 0xFF &&
1256  ChildExtension->ChildDescriptor[7] == 0x00)
1257  {
1258  if (bHaveLastMonitorID)
1259  {
1260  // Compare the previous monitor ID with the current one, break the loop if they are identical
1261  if (RtlCompareMemory(LastMonitorID, &ChildExtension->ChildDescriptor[8], sizeof(LastMonitorID)) == sizeof(LastMonitorID))
1262  {
1263  INFO_(VIDEOPRT, "Found identical Monitor ID two times, stopping enumeration\n");
1264  IoDeleteDevice(ChildDeviceObject);
1265  break;
1266  }
1267  }
1268 
1269  // Copy 10 bytes from the EDID, which can be used to uniquely identify the monitor
1270  RtlCopyMemory(LastMonitorID, &ChildExtension->ChildDescriptor[8], sizeof(LastMonitorID));
1271  bHaveLastMonitorID = TRUE;
1272 
1273  /* Mark it valid */
1274  ChildExtension->EdidValid = TRUE;
1275  }
1276  else
1277  {
1278  /* Mark it invalid */
1279  ChildExtension->EdidValid = FALSE;
1280  }
1281  }
1282  }
1283  else if (Status == VIDEO_ENUM_INVALID_DEVICE)
1284  {
1285  WARN_(VIDEOPRT, "Child device %d is invalid!\n", ChildEnumInfo.ChildIndex);
1286  IoDeleteDevice(ChildDeviceObject);
1287  continue;
1288  }
1289  else if (Status == VIDEO_ENUM_NO_MORE_DEVICES)
1290  {
1291  INFO_(VIDEOPRT, "End of child enumeration! (%d children enumerated)\n", i - 1);
1292  IoDeleteDevice(ChildDeviceObject);
1293  break;
1294  }
1295  else
1296  {
1297  WARN_(VIDEOPRT, "HwGetVideoChildDescriptor returned unknown status code 0x%x!\n", Status);
1298  IoDeleteDevice(ChildDeviceObject);
1299  break;
1300  }
1301 
1302  if (ChildExtension->ChildType == Monitor)
1303  {
1304  UINT j;
1305  PUCHAR p = ChildExtension->ChildDescriptor;
1306  INFO_(VIDEOPRT, "Monitor device enumerated! (ChildId = 0x%x)\n", ChildExtension->ChildId);
1307  for (j = 0; j < sizeof (ChildExtension->ChildDescriptor); j += 8)
1308  {
1309  INFO_(VIDEOPRT, "%02x %02x %02x %02x %02x %02x %02x %02x\n",
1310  p[j + 0], p[j + 1], p[j + 2], p[j + 3],
1311  p[j + 4], p[j + 5], p[j + 6], p[j + 7]);
1312  }
1313  }
1314  else if (ChildExtension->ChildType == Other)
1315  {
1316  INFO_(VIDEOPRT, "\"Other\" device enumerated: DeviceId = %S\n", (PWSTR)ChildExtension->ChildDescriptor);
1317  }
1318  else
1319  {
1320  ERR_(VIDEOPRT, "HwGetVideoChildDescriptor returned unsupported type: %d\n", ChildExtension->ChildType);
1321  }
1322 
1323  /* Clear the init flag */
1324  ChildDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
1325 
1326  InsertTailList(&DeviceExtension->ChildDeviceList,
1327  &ChildExtension->ListEntry);
1328  }
1329 
1330  return STATUS_SUCCESS;
1331 }
1332 
1333 VP_STATUS
1334 NTAPI
1336  IN PVOID HwDeviceExtension,
1337  IN PVOID Reserved)
1338 {
1339  PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1340 
1341  DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
1342  ASSERT(DeviceExtension);
1343 
1344  if (DeviceExtension->PhysicalDeviceObject)
1345  {
1346  /* Trigger reenumeration by the PnP manager */
1348  }
1349 
1350  return NO_ERROR;
1351 }
1352 
1353 /*
1354  * @unimplemented
1355  */
1356 VP_STATUS
1357 NTAPI
1359  IN PVOID HwDeviceExtension,
1360  IN OUT PVOID *SecondaryDeviceExtension,
1361  IN ULONG Flag)
1362 {
1364  PVIDEO_PORT_DEVICE_EXTENSION FirstDeviceExtension, DeviceExtension;
1365  NTSTATUS Status;
1366 
1367  ASSERT(SecondaryDeviceExtension);
1368 
1369  if (Flag != 0)
1370  {
1371  UNIMPLEMENTED;
1372  }
1373 
1374  FirstDeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
1375 
1376  if (FirstDeviceExtension->DisplayNumber != 0)
1377  {
1378  DPRINT1("Calling VideoPortCreateSecondaryDisplay for InstanceId %lu\n",
1379  FirstDeviceExtension->DisplayNumber);
1380  }
1381 
1383  FirstDeviceExtension->DriverExtension,
1384  FirstDeviceExtension->PhysicalDeviceObject,
1385  FirstDeviceExtension->AdapterNumber,
1386  FirstDeviceExtension->NumberOfSecondaryDisplays + 1,
1387  &DeviceObject);
1388  if (!NT_SUCCESS(Status))
1389  {
1390  DPRINT1("IntVideoPortCreateAdapterDeviceObject() failed with status 0x%08x\n", Status);
1391  return ERROR_DEV_NOT_EXIST;
1392  }
1393 
1394  DeviceExtension = DeviceObject->DeviceExtension;
1395 
1396  /* Increment secondary display count */
1397  FirstDeviceExtension->NumberOfSecondaryDisplays++;
1398 
1399  *SecondaryDeviceExtension = DeviceExtension->MiniPortDeviceExtension;
1400  return NO_ERROR;
1401 }
1402 
1403 /*
1404  * @implemented
1405  */
1406 BOOLEAN
1407 NTAPI
1409  IN PVOID HwDeviceExtension,
1411  IN PVOID Context)
1412 {
1413  return KeInsertQueueDpc(
1414  &VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension)->DpcObject,
1416  (PVOID)Context);
1417 }
1418 
1419 /*
1420  * @implemented
1421  */
1422 PVOID
1423 NTAPI
1426 {
1427  PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1428 
1429  TRACE_(VIDEOPRT, "VideoPortGetAssociatedDeviceExtension\n");
1430  DeviceExtension = ((PDEVICE_OBJECT)DeviceObject)->DeviceExtension;
1431  if (!DeviceExtension)
1432  return NULL;
1433  return DeviceExtension->MiniPortDeviceExtension;
1434 }
1435 
1436 /*
1437  * @implemented
1438  */
1439 VP_STATUS
1440 NTAPI
1442  IN PVOID HwDeviceExtension,
1443  IN OUT PVPOSVERSIONINFO VpOsVersionInfo)
1444 {
1446 
1447  Version.dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW);
1448  if (VpOsVersionInfo->Size >= sizeof(VPOSVERSIONINFO))
1449  {
1450 #if 1
1452  {
1453  VpOsVersionInfo->MajorVersion = Version.dwMajorVersion;
1454  VpOsVersionInfo->MinorVersion = Version.dwMinorVersion;
1455  VpOsVersionInfo->BuildNumber = Version.dwBuildNumber;
1456  VpOsVersionInfo->ServicePackMajor = Version.wServicePackMajor;
1457  VpOsVersionInfo->ServicePackMinor = Version.wServicePackMinor;
1458  return NO_ERROR;
1459  }
1460  return ERROR_INVALID_PARAMETER;
1461 #else
1462  VpOsVersionInfo->MajorVersion = 5;
1463  VpOsVersionInfo->MinorVersion = 0;
1464  VpOsVersionInfo->BuildNumber = 2195;
1465  VpOsVersionInfo->ServicePackMajor = 4;
1466  VpOsVersionInfo->ServicePackMinor = 0;
1467  return NO_ERROR;
1468 #endif
1469  }
1470 
1471  return ERROR_INVALID_PARAMETER;
1472 }
1473 
1474 /*
1475  * @implemented
1476  */
1477 BOOLEAN
1478 NTAPI
1480  IN PVOID HwDeviceExtension,
1481  IN USHORT VendorId,
1482  IN USHORT DeviceId,
1483  IN UCHAR RevisionId,
1484  IN USHORT SubVendorId,
1485  IN USHORT SubSystemId,
1486  IN ULONG Flags)
1487 {
1488  PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1491  IO_STACK_LOCATION IoStack;
1492  ULONG PciFlags = 0;
1493  NTSTATUS Status;
1494  BOOL DevicePresent;
1495 
1496  TRACE_(VIDEOPRT, "VideoPortCheckForDeviceExistence\n");
1497 
1499  {
1500  WARN_(VIDEOPRT, "VideoPortCheckForDeviceExistence: Unknown flags 0x%lx\n", Flags & ~(CDE_USE_REVISION | CDE_USE_SUBSYSTEM_IDS));
1501  return FALSE;
1502  }
1503 
1504  DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
1505 
1507  PciDevicePresentInterface.Version = 1;
1509  IoStack.Parameters.QueryInterface.Version = PciDevicePresentInterface.Version;
1511  IoStack.Parameters.QueryInterface.InterfaceType =
1512  &GUID_PCI_DEVICE_PRESENT_INTERFACE;
1513  Status = IopInitiatePnpIrp(DeviceExtension->NextDeviceObject,
1515  if (!NT_SUCCESS(Status))
1516  {
1517  WARN_(VIDEOPRT, "IopInitiatePnpIrp() failed! (Status 0x%lx)\n", Status);
1518  return FALSE;
1519  }
1520 
1521  if (Flags & CDE_USE_REVISION)
1522  PciFlags |= PCI_USE_REVISION;
1524  PciFlags |= PCI_USE_SUBSYSTEM_IDS;
1525 
1526  DevicePresent = PciDevicePresentInterface.IsDevicePresent(
1527  VendorId, DeviceId, RevisionId,
1528  SubVendorId, SubSystemId, PciFlags);
1529 
1530  PciDevicePresentInterface.InterfaceDereference(PciDevicePresentInterface.Context);
1531 
1532  return DevicePresent;
1533 }
1534 
1535 /*
1536  * @unimplemented
1537  */
1538 VP_STATUS
1539 NTAPI
1541  IN PVOID HwDeviceExtension,
1542  IN ULONG BugcheckCode,
1544  IN ULONG BugcheckDataSize)
1545 {
1546  UNIMPLEMENTED;
1547  return NO_ERROR;
1548 }
1549 
1550 /*
1551  * @implemented
1552  */
1553 LONGLONG
1554 NTAPI
1556  IN PVOID HwDeviceExtension,
1557  OUT PLONGLONG PerformanceFrequency OPTIONAL)
1558 {
1560 
1561  TRACE_(VIDEOPRT, "VideoPortQueryPerformanceCounter\n");
1562  Result = KeQueryPerformanceCounter((PLARGE_INTEGER)PerformanceFrequency);
1563  return Result.QuadPart;
1564 }
1565 
1566 /*
1567  * @implemented
1568  */
1569 VOID
1570 NTAPI
1572  IN PVOID HwDeviceExtension)
1573 {
1574  PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1575 
1576  TRACE_(VIDEOPRT, "VideoPortAcquireDeviceLock\n");
1577  DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
1579  // ASSERT(Status == STATUS_SUCCESS);
1580 }
1581 
1582 /*
1583  * @implemented
1584  */
1585 VOID
1586 NTAPI
1588  IN PVOID HwDeviceExtension)
1589 {
1590  PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1591 
1592  TRACE_(VIDEOPRT, "VideoPortReleaseDeviceLock\n");
1593  DeviceExtension = VIDEO_PORT_GET_DEVICE_EXTENSION(HwDeviceExtension);
1594  KeReleaseMutex(&DeviceExtension->DeviceLock, FALSE);
1595  //ASSERT(Status == STATUS_SUCCESS);
1596 }
1597 
1598 /*
1599  * @unimplemented
1600  */
1601 VOID
1602 NTAPI
1605  IN PVOID Data)
1606 {
1607  UNIMPLEMENTED;
1608 }
1609 
1610 /*
1611  * @implemented
1612  */
1613 PVOID
1614 NTAPI
1616  IN PVOID HwDeviceExtension,
1619 )
1620 {
1622 }
1623 
1624 /*
1625  * @implemented
1626  */
1627 BOOLEAN
1628 NTAPI
1630 {
1631  return VpNoVesa;
1632 }
VOID FASTCALL IntLoadRegistryParameters(VOID)
Definition: videoprt.c:515
#define DO_DEVICE_INITIALIZING
Definition: env_spec_w32.h:399
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
NTSTATUS NTAPI IntVideoPortFindAdapter(IN PDRIVER_OBJECT DriverObject, IN PVIDEO_PORT_DRIVER_EXTENSION DriverExtension, IN PDEVICE_OBJECT DeviceObject)
Definition: videoprt.c:341
_In_ WDFIORESREQLIST _In_ ULONG SlotNumber
Definition: wdfresource.h:65
#define STATUS_REVISION_MISMATCH
Definition: ntstatus.h:325
signed char * PCHAR
Definition: retypes.h:7
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
PVOID NTAPI IntVideoPortImageDirectoryEntryToData(PVOID BaseAddress, ULONG Directory)
Definition: videoprt.c:116
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
_Must_inspect_result_ typedef _In_ PVOID Unused
Definition: iotypes.h:1166
#define ASSERT_IRQL_LESS_OR_EQUAL(x)
Definition: debug.h:251
_In_ PCWSTR _Inout_ _At_ QueryTable _Pre_unknown_ PRTL_QUERY_REGISTRY_TABLE QueryTable
Definition: rtlfuncs.h:4155
#define IN
Definition: typedefs.h:39
UNICODE_STRING NewRegistryPath
Definition: videoprt.h:91
VOID NTAPI VpNotifyEaData(IN PDEVICE_OBJECT DeviceObject, IN PVOID Data)
Definition: videoprt.c:1603
NTSTATUS NTAPI IntVideoPortDispatchPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:1134
LARGE_INTEGER NTAPI KeQueryPerformanceCounter(IN PLARGE_INTEGER PerformanceFreq)
Definition: timer.c:138
#define TAG_VIDEO_PORT
Definition: videoprt.h:38
KAPC_STATE
Definition: ketypes.h:1285
#define IRP_MJ_CREATE
Definition: rdpdr.c:44
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define PCI_MAX_BRIDGE_NUMBER
Definition: iotypes.h:3600
_In_ NDIS_ERROR_CODE ErrorCode
Definition: ndis.h:4436
PDEVICE_OBJECT FunctionalDeviceObject
Definition: videoprt.h:88
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
VIDEO_CHILD_TYPE ChildType
Definition: videoprt.h:121
_IRQL_requires_same_ typedef _In_ ULONG _In_ UCHAR _In_ ULONGLONG _In_ ULONGLONG _In_opt_ PEVENT_FILTER_DESCRIPTOR _Inout_opt_ PVOID CallbackContext
Definition: wmitypes.h:55
IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]
Definition: ntddk_ex.h:178
_Must_inspect_result_ _In_ PWDF_DPC_CONFIG _In_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFDPC * Dpc
Definition: wdfdpc.h:107
NTSTATUS NTAPI IntCreateNewRegistryPath(PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension)
Definition: registry.c:407
VOID NTAPI IntVideoPortDeferredRoutine(IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
Definition: videoprt.c:139
#define _In_opt_
Definition: ms_sal.h:309
BOOLEAN VpBaseVideo
Definition: videoprt.c:36
NTSTATUS NTAPI RtlGetVersion(IN OUT PRTL_OSVERSIONINFOW lpVersionInformation)
Definition: version.c:158
#define INFO_(ch,...)
Definition: debug.h:159
NTSYSAPI NTSTATUS WINAPI RtlQueryRegistryValues(ULONG, PCWSTR, PRTL_QUERY_REGISTRY_TABLE, PVOID, PVOID)
NTSTATUS NTAPI IoAllocateDriverObjectExtension(IN PDRIVER_OBJECT DriverObject, IN PVOID ClientIdentificationAddress, IN ULONG DriverObjectExtensionSize, OUT PVOID *DriverObjectExtension)
Definition: driver.c:1797
#define KeWaitForMutexObject
Definition: kefuncs.h:555
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4711
PVIDEO_HW_GET_CHILD_DESCRIPTOR HwGetVideoChildDescriptor
Definition: video.h:677
VIDEO_PORT_DRIVER_EXTENSION * DriverExtension
Definition: videoprt.h:103
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define ERROR_INVALID_FUNCTION
Definition: dderror.h:6
NTSTATUS NTAPI IntCreateRegistryPath(IN PCUNICODE_STRING DriverRegistryPath, IN ULONG DeviceNumber, OUT PUNICODE_STRING DeviceRegistryPath)
Definition: registry.c:601
#define IRP_MJ_SHUTDOWN
#define REG_BINARY
Definition: nt_native.h:1496
PVOID NTAPI VideoPortAllocateContiguousMemory(IN PVOID HwDeviceExtension, IN ULONG NumberOfBytes, IN PHYSICAL_ADDRESS HighestAcceptableAddress)
Definition: videoprt.c:1615
#define TRUE
Definition: types.h:120
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
_CONST_RETURN wchar_t *__cdecl wcsstr(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_SubStr)
struct _DEVICE_OBJECT * PDEVICE_OBJECT
uint16_t * PWSTR
Definition: typedefs.h:56
VIDEO_HW_INITIALIZATION_DATA InitializationData
Definition: videoprt.h:72
unsigned char * PUCHAR
Definition: retypes.h:3
BOOLEAN NTAPI VideoPortScanRom(IN PVOID HwDeviceExtension, IN PUCHAR RomBase, IN ULONG RomLength, IN PUCHAR String)
Definition: videoprt.c:1089
BOOLEAN NTAPI IntVideoPortSetupTimer(IN PDEVICE_OBJECT DeviceObject, IN PVIDEO_PORT_DRIVER_EXTENSION DriverExtension)
Definition: timer.c:43
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
#define ERR_(ch,...)
Definition: debug.h:156
BOOLEAN NTAPI KeInsertQueueDpc(IN PKDPC Dpc, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
Definition: dpc.c:725
LONG NTSTATUS
Definition: precomp.h:26
_Must_inspect_result_ _In_ PDRIVER_OBJECT _In_ PCUNICODE_STRING RegistryPath
Definition: wdfdriver.h:213
PVOID NTAPI VideoPortGetAssociatedDeviceExtension(IN PVOID DeviceObject)
Definition: videoprt.c:1424
_Must_inspect_result_ _In_ PVOID _In_ struct _HW_INITIALIZATION_DATA _In_ PVOID HwContext
Definition: srb.h:897
struct _VIDEO_PORT_DEVICE_EXTENSTION * PVIDEO_PORT_DEVICE_EXTENSION
VP_STATUS NTAPI VideoPortGetVersion(IN PVOID HwDeviceExtension, IN OUT PVPOSVERSIONINFO VpOsVersionInfo)
Definition: videoprt.c:1441
VP_STATUS NTAPI VideoPortRegisterBugcheckCallback(IN PVOID HwDeviceExtension, IN ULONG BugcheckCode, IN PVIDEO_BUGCHECK_CALLBACK Callback, IN ULONG BugcheckDataSize)
Definition: videoprt.c:1540
KMUTEX VideoPortInt10Mutex
Definition: videoprt.c:41
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
VOID NTAPI IoDetachDevice(IN PDEVICE_OBJECT TargetDevice)
Definition: device.c:1296
struct QueryRegistryCallbackContext QUERY_REGISTRY_CALLBACK_CONTEXT
NTSTATUS NTAPI IntVideoPortEnumerateChildren(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: videoprt.c:1171
ULONG ChildDescriptorSize
Definition: video.h:262
#define VIDEO_PORT_GET_DEVICE_EXTENSION(MiniportExtension)
Definition: videoprt.h:140
LIST_ENTRY AddressMappingListHead
Definition: videoprt.h:101
PKPROCESS CsrProcess
Definition: videoprt.c:39
BOOLEAN NTAPI VideoPortSynchronizeExecution(IN PVOID HwDeviceExtension, IN VIDEO_SYNCHRONIZE_PRIORITY Priority, IN PMINIPORT_SYNCHRONIZE_ROUTINE SynchronizeRoutine, OUT PVOID Context)
Definition: videoprt.c:1122
NTSTATUS NTAPI IntSetupDeviceSettingsKey(PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension)
Definition: registry.c:297
struct _PCI_DEVICE_PRESENT_INTERFACE PCI_DEVICE_PRESENT_INTERFACE
uint16_t * PWCHAR
Definition: typedefs.h:56
#define swprintf
Definition: precomp.h:40
PDEVICE_OBJECT PhysicalDeviceObject
Definition: btrfs_drv.h:1155
#define InsertTailList(ListHead, Entry)
NTSTATUS NTAPI IntVideoPortDispatchDeviceControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:721
LONG NTAPI KeReleaseMutex(IN PKMUTEX Mutex, IN BOOLEAN Wait)
Definition: mutex.c:189
#define NO_ERROR
Definition: dderror.h:5
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _In_ ULONG _Out_opt_ PULONG _Out_opt_ PULONG ValueType
Definition: wdfregistry.h:279
#define FASTCALL
Definition: nt_native.h:50
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
BOOLEAN(NTAPI * PMINIPORT_SYNCHRONIZE_ROUTINE)(IN PVOID Context)
Definition: video.h:523
VP_STATUS NTAPI VideoPortSetRegistryParameters(IN PVOID HwDeviceExtension, IN PWSTR ValueName, IN PVOID ValueData, IN ULONG ValueLength)
Definition: videoprt.c:972
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
LONGLONG NTAPI VideoPortQueryPerformanceCounter(IN PVOID HwDeviceExtension, OUT PLONGLONG PerformanceFrequency OPTIONAL)
Definition: videoprt.c:1555
#define PCI_USE_REVISION
Definition: iotypes.h:867
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
static USHORT USHORT * NewLength
uint32_t ULONG_PTR
Definition: typedefs.h:65
INTERFACE_TYPE AdapterInterfaceType
Definition: video.h:169
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:683
__GNU_EXTENSION typedef __int64 * PLONGLONG
Definition: ntbasedef.h:382
UCHAR KIRQL
Definition: env_spec_w32.h:591
_Must_inspect_result_ _In_ PFLT_GET_OPERATION_STATUS_CALLBACK CallbackRoutine
Definition: fltkernel.h:1035
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
struct QueryRegistryCallbackContext * PQUERY_REGISTRY_CALLBACK_CONTEXT
#define L(x)
Definition: ntvdm.h:50
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3272
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFSTRING String
Definition: wdfdevice.h:2430
PRTL_QUERY_REGISTRY_ROUTINE QueryRoutine
Definition: nt_native.h:109
PVOID NTAPI IntVideoPortGetProcAddress(IN PVOID HwDeviceExtension, IN PUCHAR FunctionName)
Definition: funclist.c:100
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define FILE_DEVICE_CONTROLLER
Definition: winioctl.h:110
#define va_end(ap)
Definition: acmsvcex.h:90
#define FALSE
Definition: types.h:117
#define UNICODE_NULL
#define CDE_USE_REVISION
Definition: video.h:147
VOID NTAPI KeStackAttachProcess(IN PKPROCESS Process, OUT PRKAPC_STATE ApcState)
Definition: procobj.c:704
_In_ PIRP Irp
Definition: csq.h:116
NTSYSAPI NTSTATUS WINAPI RtlWriteRegistryValue(ULONG, PCWSTR, PCWSTR, ULONG, PVOID, ULONG)
unsigned int BOOL
Definition: ntddk_ex.h:94
PDEVICE_OBJECT PhysicalDeviceObject
Definition: videoprt.h:87
UCHAR NTAPI VideoPortGetCurrentIrql(VOID)
Definition: videoprt.c:880
PDEVICE_OBJECT NTAPI IoAttachDeviceToDeviceStack(IN PDEVICE_OBJECT SourceDevice, IN PDEVICE_OBJECT TargetDevice)
Definition: device.c:966
VOID NTAPI IntVideoPortUnload(PDRIVER_OBJECT DriverObject)
Definition: dispatch.c:1190
VP_STATUS NTAPI VideoPortEnumerateChildren(IN PVOID HwDeviceExtension, IN PVOID Reserved)
Definition: videoprt.c:1335
#define PsGetCurrentProcess
Definition: psfuncs.h:17
#define VIDEO_PORT_GET_CHILD_EXTENSION(MiniportExtension)
Definition: videoprt.h:134
FORCEINLINE VOID KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
Definition: kefuncs.h:238
NTSYSAPI NTSTATUS NTAPI ZwQuerySystemInformation(IN SYSTEM_INFORMATION_CLASS SystemInfoClass, OUT PVOID SystemInfoBuffer, IN ULONG SystemInfoBufferSize, OUT PULONG BytesReturned OPTIONAL)
VIDEO_PORT_COMMON_EXTENSION Common
Definition: videoprt.h:118
PVOID DeviceExtension
Definition: env_spec_w32.h:418
unsigned char BOOLEAN
_In_ PCWSTR _Inout_ _At_ QueryTable EntryContext
Definition: rtlfuncs.h:4155
struct _OSVERSIONINFOEXW RTL_OSVERSIONINFOEXW
PVIDEO_PORT_GET_PROC_ADDRESS VideoPortGetProcAddress
Definition: video.h:193
VOID NTAPI IoDisconnectInterrupt(PKINTERRUPT InterruptObject)
Definition: irq.c:140
struct _VIDEO_HW_INITIALIZATION_DATA VIDEO_HW_INITIALIZATION_DATA
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
#define _In_
Definition: ms_sal.h:308
KSPIN_LOCK HwResetAdaptersLock
Definition: videoprt.c:42
char * va_list
Definition: acmsvcex.h:78
NTSTATUS NTAPI IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject, IN DEVICE_REGISTRY_PROPERTY DeviceProperty, IN ULONG BufferLength, OUT PVOID PropertyBuffer, OUT PULONG ResultLength)
Definition: pnpmgr.c:1952
static ULONG VideoPortMaxObjectNumber
Definition: videoprt.c:40
_Reserved_ PVOID Reserved
Definition: winddi.h:3974
#define VIDEO_ENUM_MORE_DEVICES
Definition: video.h:139
return Found
Definition: dirsup.c:1270
struct _INTERFACE * PINTERFACE
NTSTATUS NTAPI IntVideoPortDispatchClose(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:436
PDRIVER_OBJECT DriverObject
Definition: videoprt.h:126
static NTSTATUS NTAPI QueryRegistryCallback(IN PWSTR ValueName, IN ULONG ValueType, IN PVOID ValueData, IN ULONG ValueLength, IN PVOID Context, IN PVOID EntryContext)
Definition: videoprt.c:895
NTSTATUS NTAPI IntVideoPortCreateAdapterDeviceObject(_In_ PDRIVER_OBJECT DriverObject, _In_ PVIDEO_PORT_DRIVER_EXTENSION DriverExtension, _In_opt_ PDEVICE_OBJECT PhysicalDeviceObject, _In_ USHORT AdapterNumber, _In_ USHORT DisplayNumber, _Out_opt_ PDEVICE_OBJECT *DeviceObject)
Definition: videoprt.c:152
_In_opt_ PUNICODE_STRING _In_ PDRIVER_OBJECT _In_ PDEVICE_OBJECT _In_ INTERFACE_TYPE _In_ ULONG BusNumber
Definition: halfuncs.h:156
_Must_inspect_result_ _In_ PDRIVER_OBJECT DriverObject
Definition: wdfdriver.h:213
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
Status
Definition: gdiplustypes.h:24
_In_opt_ PVOID _In_opt_ PVOID SystemArgument1
Definition: ketypes.h:675
#define TRACE_(x)
Definition: compat.h:76
int64_t LONGLONG
Definition: typedefs.h:68
ULONGLONG SystemMemorySize
Definition: video.h:195
#define CDE_USE_SUBSYSTEM_IDS
Definition: video.h:146
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
VP_STATUS(NTAPI * PMINIPORT_GET_REGISTRY_ROUTINE)(IN PVOID HwDeviceExtension, IN PVOID Context, IN OUT PWSTR ValueName, IN OUT PVOID ValueData, IN ULONG ValueLength)
Definition: video.h:510
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
VP_STATUS NTAPI VideoPortGetVgaStatus(IN PVOID HwDeviceExtension, OUT PULONG VgaStatus)
Definition: videoprt.c:1003
_In_ PKSYNCHRONIZE_ROUTINE SynchronizeRoutine
Definition: kefuncs.h:536
#define ASSERT(a)
Definition: mode.c:44
ULONG VideoDebugLevel
Definition: videoprt.c:34
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define FILE_DEVICE_VIDEO
Definition: winioctl.h:141
PLIST_ENTRY NTAPI ExInterlockedInsertTailList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:140
#define DO_BUFFERED_IO
Definition: env_spec_w32.h:394
ULONG NTAPI DriverEntry(IN PVOID Context1, IN PVOID Context2)
Definition: videoprt.c:49
#define SIZE_OF_NT4_VIDEO_HW_INITIALIZATION_DATA
Definition: video.h:119
Definition: video.h:273
SYSTEM_BASIC_INFORMATION SystemBasicInfo
Definition: perfdata.c:45
Definition: xml2sdb.h:79
VOID NTAPI VideoPortLogError(IN PVOID HwDeviceExtension, IN PVIDEO_REQUEST_PACKET Vrp OPTIONAL, IN VP_STATUS ErrorCode, IN ULONG UniqueId)
Definition: videoprt.c:861
_In_ GUID _In_ PVOID ValueData
Definition: hubbusif.h:311
NTSTATUS NTAPI IntVideoPortDispatchSystemControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:1168
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
va_start(ap, x)
BOOL Error
Definition: chkdsk.c:66
CHAR POINTER_ALIGNMENT MiniPortDeviceExtension[1]
Definition: videoprt.h:113
IN PVOID IN PVOID IN USHORT Version
Definition: pci.h:361
#define IRP_MN_QUERY_INTERFACE
NTSYSAPI ULONG NTAPI vDbgPrintEx(_In_ ULONG ComponentId, _In_ ULONG Level, _In_z_ PCCH Format, _In_ va_list ap)
#define READ_CONTROL
Definition: nt_native.h:58
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
struct _VIDEO_PORT_CONFIG_INFO VIDEO_PORT_CONFIG_INFO
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING ValueName
Definition: wdfregistry.h:240
BOOLEAN VpNoVesa
Definition: videoprt.c:37
_In_ WDFINTERRUPT _In_ WDF_INTERRUPT_POLICY _In_ WDF_INTERRUPT_PRIORITY Priority
Definition: wdfinterrupt.h:651
unsigned char UCHAR
Definition: xmlstorage.h:181
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3378
VOID NTAPI KeInitializeMutex(IN PKMUTEX Mutex, IN ULONG Level)
Definition: mutex.c:67
#define IRP_MJ_POWER
#define IRP_MJ_CLOSE
Definition: rdpdr.c:45
VIDEO_SYNCHRONIZE_PRIORITY
Definition: video.h:534
PWSTR DriverRegistryPath
Definition: video.h:194
NTSTATUS NTAPI IntVideoPortAddDevice(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject)
Definition: dispatch.c:334
VOID(NTAPI * PMINIPORT_DPC_ROUTINE)(IN PVOID HwDeviceExtension, IN PVOID Context)
Definition: video.h:518
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:790
Definition: ketypes.h:687
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
_In_opt_ PWSTR _In_ PWSTR ParameterName
Definition: cdrom.h:960
VOID NTAPI VideoPortAcquireDeviceLock(IN PVOID HwDeviceExtension)
Definition: videoprt.c:1571
PVOID NTAPI IoGetDriverObjectExtension(IN PDRIVER_OBJECT DriverObject, IN PVOID ClientIdentificationAddress)
Definition: driver.c:1875
_Out_ PNDIS_HANDLE _Out_ PUINT _In_ PNDIS_STRING _In_ NDIS_PHYSICAL_ADDRESS HighestAcceptableAddress
Definition: ndis.h:3227
PDEVICE_OBJECT NextDeviceObject
Definition: videoprt.h:89
#define SYNCH_LEVEL
Definition: env_spec_w32.h:704
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
#define RTL_REGISTRY_ABSOLUTE
Definition: nt_native.h:161
#define IRP_MJ_SYSTEM_CONTROL
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
_In_ PNET_PNP_EVENT _In_ PTDI_PNP_CONTEXT _In_ PTDI_PNP_CONTEXT Context2
Definition: tdikrnl.h:1094
PDRIVER_OBJECT DriverObject
Definition: videoprt.h:86
_In_opt_ PVOID _In_opt_ PVOID _In_opt_ PVOID SystemArgument2
Definition: ketypes.h:675
_In_ WDFINTERRUPT _In_ PFN_WDF_INTERRUPT_SYNCHRONIZE Callback
Definition: wdfinterrupt.h:456
struct _VIDEO_PORT_DEVICE_EXTENSTION VIDEO_PORT_DEVICE_EXTENSION
VOID VideoPortDebugPrint(IN VIDEO_DEBUG_LEVEL DebugPrintLevel, IN PCHAR DebugMessage,...)
Definition: videoprt.c:841
ULONG_PTR SIZE_T
Definition: typedefs.h:80
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1251
VOID(NTAPI * PVIDEO_BUGCHECK_CALLBACK)(IN PVOID HwDeviceExtension, IN ULONG BugcheckCode, IN PUCHAR Buffer, IN ULONG BufferSize)
Definition: video.h:527
VOID NTAPI IoInvalidateDeviceRelations(IN PDEVICE_OBJECT DeviceObject, IN DEVICE_RELATION_TYPE Type)
Definition: pnpmgr.c:2342
PRTL_UNICODE_STRING_BUFFER Path
Definition: video.h:270
VOID FASTCALL IntAttachToCSRSS(PKPROCESS *CallingProcess, PKAPC_STATE ApcState)
Definition: videoprt.c:490
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
unsigned short USHORT
Definition: pedump.c:61
struct _KPROCESS * PKPROCESS
Definition: wdm.template.h:206
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
VOID NTAPI KeUnstackDetachProcess(IN PRKAPC_STATE ApcState)
Definition: procobj.c:756
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
BOOLEAN NTAPI IntVideoPortSetupInterrupt(IN PDEVICE_OBJECT DeviceObject, IN PVIDEO_PORT_DRIVER_EXTENSION DriverExtension, IN PVIDEO_PORT_CONFIG_INFO ConfigInfo)
Definition: interrupt.c:45
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
_Out_ PKAPC_STATE ApcState
Definition: mm.h:1700
_In_ PNET_PNP_EVENT _In_ PTDI_PNP_CONTEXT Context1
Definition: tdikrnl.h:1094
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
static NTSTATUS IntVideoPortAddDeviceMapLink(PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension)
Definition: videoprt.c:58
ULONG NTAPI VideoPortInitialize(IN PVOID Context1, IN PVOID Context2, IN PVIDEO_HW_INITIALIZATION_DATA HwInitializationData, IN PVOID HwContext)
Definition: videoprt.c:639
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define _Out_opt_
Definition: ms_sal.h:346
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS _Inout_ PLARGE_INTEGER NumberOfBytes
Definition: iotypes.h:1035
unsigned int * PULONG
Definition: retypes.h:1
BOOLEAN NTAPI VideoPortIsNoVesa(VOID)
Definition: videoprt.c:1629
#define min(a, b)
Definition: monoChain.cc:55
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
PVOID NTAPI MmAllocateContiguousMemory(IN SIZE_T NumberOfBytes, IN PHYSICAL_ADDRESS HighestAcceptableAddress)
Definition: contmem.c:626
VOID NTAPI KeRaiseIrql(KIRQL NewIrql, PKIRQL OldIrql)
Definition: spinlock.c:27
VIDEO_PORT_COMMON_EXTENSION Common
Definition: videoprt.h:84
#define DPRINT1
Definition: precomp.h:8
#define RtlImageNtHeader
Definition: compat.h:665
NTSTATUS NTAPI IntVideoPortDispatchPnp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:1102
HRESULT QueryInterface([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
struct tagContext Context
Definition: acpixf.h:1034
void int int ULONGLONG int va_list * ap
Definition: winesup.h:32
#define OUT
Definition: typedefs.h:40
NTSTATUS NTAPI IntVideoPortDispatchOpen(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:369
VIDEO_DEBUG_LEVEL
Definition: video.h:579
PDEVICE_OBJECT PhysicalDeviceObject
Definition: videoprt.h:127
PPCI_DRIVER_EXTENSION DriverExtension
Definition: pci.c:31
VOID FASTCALL IntDetachFromCSRSS(PKPROCESS *CallingProcess, PKAPC_STATE ApcState)
Definition: videoprt.c:503
unsigned int ULONG
Definition: retypes.h:1
NTSTATUS NTAPI IoCreateDevice(IN PDRIVER_OBJECT DriverObject, IN ULONG DeviceExtensionSize, IN PUNICODE_STRING DeviceName, IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN Exclusive, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1031
base for all directory entries
Definition: entries.h:138
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define UNIMPLEMENTED
Definition: debug.h:115
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define ULONG_PTR
Definition: config.h:101
RTL_STATIC_LIST_HEAD(HwResetAdaptersList)
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
BOOLEAN NTAPI KeSynchronizeExecution(IN OUT PKINTERRUPT Interrupt, IN PKSYNCHRONIZE_ROUTINE SynchronizeRoutine, IN PVOID SynchronizeContext OPTIONAL)
Definition: interrupt.c:165
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
LIST_ENTRY HwResetAdaptersList
LONG VP_STATUS
Definition: video.h:153
UNICODE_STRING RegistryPath
Definition: videoprt.h:90
PVOID ChildHwDeviceExtension
Definition: video.h:265
PCI_INTERFACE PciDevicePresentInterface
Definition: devhere.c:18
#define FILE_DEVICE_SECURE_OPEN
Definition: cdrw_usr.h:46
PVOID NTAPI VideoPortGetRomImage(IN PVOID HwDeviceExtension, IN PVOID Unused1, IN ULONG Unused2, IN ULONG Length)
Definition: videoprt.c:1031
#define STATUS_SUCCESS
Definition: shellext.h:65
#define SIZE_OF_W2K_VIDEO_HW_INITIALIZATION_DATA
Definition: video.h:120
#define REG_OPTION_VOLATILE
Definition: nt_native.h:1060
_In_ PCHAR _In_ ULONG DeviceNumber
Definition: classpnp.h:1229
GLfloat GLfloat p
Definition: glext.h:8902
#define RTL_REGISTRY_DEVICEMAP
Definition: nt_native.h:165
VOID NTAPI KeLowerIrql(KIRQL NewIrql)
Definition: spinlock.c:39
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3128
VOID NTAPI KeInitializeDpc(IN PKDPC Dpc, IN PKDEFERRED_ROUTINE DeferredRoutine, IN PVOID DeferredContext)
Definition: dpc.c:712
VP_STATUS NTAPI VideoPortGetRegistryParameters(IN PVOID HwDeviceExtension, IN PWSTR ParameterName, IN UCHAR IsParameterFileName, IN PMINIPORT_GET_REGISTRY_ROUTINE GetRegistryRoutine, IN PVOID HwContext)
Definition: videoprt.c:921
_In_ BOOLEAN _In_ USHORT Directory
Definition: rtlfuncs.h:3885
INTERFACE_TYPE AdapterInterfaceType
Definition: videoprt.h:98
#define RTL_QUERY_REGISTRY_REQUIRED
Definition: nt_native.h:132
#define REG_DWORD
Definition: sdbapi.c:596
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define VIDEO_ENUM_NO_MORE_DEVICES
Definition: video.h:140
NTSTATUS NTAPI IopInitiatePnpIrp(IN PDEVICE_OBJECT DeviceObject, IN PIO_STATUS_BLOCK IoStatusBlock, IN UCHAR MinorFunction, IN PIO_STACK_LOCATION Stack)
#define ERROR_DEV_NOT_EXIST
Definition: dderror.h:8
#define WARN_(ch,...)
Definition: debug.h:157
BOOLEAN NTAPI VideoPortQueueDpc(IN PVOID HwDeviceExtension, IN PMINIPORT_DPC_ROUTINE CallbackRoutine, IN PVOID Context)
Definition: videoprt.c:1408
PMINIPORT_GET_REGISTRY_ROUTINE HwGetRegistryRoutine
Definition: videoprt.c:889
VP_STATUS NTAPI VideoPortCreateSecondaryDisplay(IN PVOID HwDeviceExtension, IN OUT PVOID *SecondaryDeviceExtension, IN ULONG Flag)
Definition: videoprt.c:1358
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
* PKAPC_STATE
Definition: ketypes.h:1285
ULONG BusInterruptVector
Definition: video.h:171
#define RtlCompareMemory(s1, s2, l)
Definition: env_spec_w32.h:465
_Must_inspect_result_ _In_ PVOID _In_ struct _HW_INITIALIZATION_DATA * HwInitializationData
Definition: srb.h:897
#define PCI_USE_SUBSYSTEM_IDS
Definition: iotypes.h:866
BOOLEAN NTAPI VideoPortCheckForDeviceExistence(IN PVOID HwDeviceExtension, IN USHORT VendorId, IN USHORT DeviceId, IN UCHAR RevisionId, IN USHORT SubVendorId, IN USHORT SubSystemId, IN ULONG Flags)
Definition: videoprt.c:1479
KINTERRUPT_MODE InterruptMode
Definition: video.h:172
VOID NTAPI VideoPortReleaseDeviceLock(IN PVOID HwDeviceExtension)
Definition: videoprt.c:1587
#define IRP_MJ_DEVICE_CONTROL
Definition: rdpdr.c:52
#define VIDEO_ENUM_INVALID_DEVICE
Definition: video.h:141
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
#define REG_SZ
Definition: layer.c:22
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _In_ ULONG ValueLength
Definition: wdfregistry.h:271
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
_In_opt_ PVOID DeferredContext
Definition: ketypes.h:675