ReactOS 0.4.15-dev-7924-g5949c20
dispatch.c
Go to the documentation of this file.
1/*
2 * VideoPort driver
3 *
4 * Copyright (C) 2002, 2003, 2004 ReactOS Team
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 */
21
22#include "videoprt.h"
23
24#include <ndk/inbvfuncs.h>
25#include <ndk/obfuncs.h>
26#include <ndk/psfuncs.h>
27
28#define NDEBUG
29#include <debug.h>
30
31/* GLOBAL VARIABLES ***********************************************************/
32
36
37/* PRIVATE FUNCTIONS **********************************************************/
38
39static VOID
42{
43 if (!Win32kCallout)
44 return;
45
46 /* Perform the call in the context of CSRSS */
47 if (!CsrProcess)
48 return;
49
51 Win32kCallout(CallbackParams);
53}
54
55/*
56 * Reinitialize the display to base VGA mode.
57 *
58 * Returns TRUE if it completely resets the adapter to the given character mode.
59 * Returns FALSE otherwise, indicating that the HAL should perform the VGA mode
60 * reset itself after HwVidResetHw() returns control.
61 *
62 * This callback has been registered with InbvNotifyDisplayOwnershipLost()
63 * and is called by InbvAcquireDisplayOwnership(), typically when the bugcheck
64 * code regains display access. Therefore this routine can be called at any
65 * IRQL, and in particular at IRQL = HIGH_LEVEL. This routine must also reside
66 * completely in non-paged pool, and cannot perform the following actions:
67 * Allocate memory, access pageable memory, use any synchronization mechanisms
68 * or call any routine that must execute at IRQL = DISPATCH_LEVEL or below.
69 */
70static BOOLEAN
75 _In_ BOOLEAN CalledByInbv)
76{
77 BOOLEAN Success = TRUE; // Suppose we don't need to perform a full reset.
79 PLIST_ENTRY PrevEntry, Entry;
80 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
82
83 /* Check if we are at dispatch level or lower, and acquire the lock */
86 {
87 /* Loop until the lock is free, then raise IRQL to dispatch level */
90 }
92
93 /* Bail out early if we don't have any resettable adapter */
95 {
96 Success = FALSE; // No adapter found: request HAL to perform a full reset.
97 goto Quit;
98 }
99
100 /*
101 * If we have been unexpectedly called via a callback from
102 * InbvAcquireDisplayOwnership(), start monitoring INBV.
103 */
104 if (CalledByInbv)
106
107 for (PrevEntry = &HwResetAdaptersList, Entry = PrevEntry->Flink;
109 PrevEntry = Entry, Entry = Entry->Flink)
110 {
111 /*
112 * Check whether the entry address is properly aligned,
113 * the device and driver extensions must be readable and
114 * the device extension properly back-linked to the last entry.
115 */
116// #define IS_ALIGNED(addr, align) (((ULONG64)(addr) & (align - 1)) == 0)
117 if (((ULONG_PTR)Entry & (sizeof(ULONG_PTR) - 1)) != 0)
118 {
119 Success = FALSE; // We failed: request HAL to perform a full reset.
120 goto Quit;
121 }
122
123 DeviceExtension = CONTAINING_RECORD(Entry,
125 HwResetListEntry);
126 /*
127 * As this function can be called as part of the INBV initialization
128 * by the bugcheck code, avoid any problems and protect all accesses
129 * within SEH.
130 */
132 {
133 DriverExtension = DeviceExtension->DriverExtension;
135
136 if (DeviceExtension->HwResetListEntry.Blink != PrevEntry)
137 {
138 Success = FALSE; // We failed: request HAL to perform a full reset.
139 _SEH2_YIELD(goto Quit);
140 }
141
142 if ((DeviceExtension->DeviceOpened >= 1) &&
143 (DriverExtension->InitializationData.HwResetHw != NULL))
144 {
145 Success &= DriverExtension->InitializationData.HwResetHw(
146 &DeviceExtension->MiniPortDeviceExtension,
147 Columns, Rows);
148 }
149 }
151 {
152 }
153 _SEH2_END;
154 }
155
156Quit:
157 /* Release the lock and restore the old IRQL if we were at dispatch level or lower */
159 if (OldIrql <= DISPATCH_LEVEL)
161
162 return Success;
163}
164
165/* This callback is registered with InbvNotifyDisplayOwnershipLost() */
166static BOOLEAN
167NTAPI
169{
170 /* Call the extended function, specifying we were called by INBV */
172}
173
174/*
175 * (Adapted for ReactOS/Win2k3 from an original comment
176 * by Gé van Geldorp, June 2003, r4937)
177 *
178 * DISPLAY OWNERSHIP
179 *
180 * So, who owns the physical display and is allowed to write to it?
181 *
182 * In NT 5.x (Win2k/Win2k3), upon boot INBV/BootVid owns the display, unless
183 * /NOGUIBOOT has been specified in the boot command line. Later in the boot
184 * sequence, WIN32K.SYS opens the DISPLAY device. This open call ends up in
185 * VIDEOPRT.SYS. This component takes ownership of the display by calling
186 * InbvNotifyDisplayOwnershipLost() -- effectively telling INBV to release
187 * ownership of the display it previously had. From that moment on, the display
188 * is owned by that component and can be switched to graphics mode. The display
189 * is not supposed to return to text mode, except in case of a bugcheck.
190 * The bugcheck code calls InbvAcquireDisplayOwnership() so as to make INBV
191 * re-take display ownership, and calls back the function previously registered
192 * by VIDEOPRT.SYS with InbvNotifyDisplayOwnershipLost(). After the bugcheck,
193 * execution is halted. So, under NT, the only possible sequence of display
194 * modes is text mode -> graphics mode -> text mode (the latter hopefully
195 * happening very infrequently).
196 *
197 * In ReactOS things are a little bit different. We want to have a functional
198 * interactive text mode. We should be able to switch back and forth from
199 * text mode to graphics mode when a GUI app is started and then finished.
200 * Also, when the system bugchecks in graphics mode we want to switch back to
201 * text mode and show the bugcheck information. Last but not least, when using
202 * KDBG in /DEBUGPORT=SCREEN mode, breaking into the debugger would trigger a
203 * switch to text mode, and the user would expect that by continuing execution
204 * a switch back to graphics mode is done.
205 */
206static VOID
207NTAPI
210{
211 VIDEO_WIN32K_CALLBACKS_PARAMS CallbackParams;
212 LARGE_INTEGER Delay;
213 USHORT i;
214
216
217 while (TRUE)
218 {
219 /*
220 * During one second, check the INBV status each 100 milliseconds,
221 * then revert to 1 second delay.
222 */
223 i = 10;
224 Delay.QuadPart = (LONGLONG)-100*1000*10; // 100 millisecond delay
225 while (!InbvMonitoring)
226 {
228
229 if ((i > 0) && (--i == 0))
230 Delay.QuadPart = (LONGLONG)-1*1000*1000*10; // 1 second delay
231 }
232
233 /*
234 * Loop while the display is owned by INBV. We cannot do anything else
235 * than polling since INBV does not offer a proper notification system.
236 *
237 * During one second, check the INBV status each 100 milliseconds,
238 * then revert to 1 second delay.
239 */
240 i = 10;
241 Delay.QuadPart = (LONGLONG)-100*1000*10; // 100 millisecond delay
243 {
245
246 if ((i > 0) && (--i == 0))
247 Delay.QuadPart = (LONGLONG)-1*1000*1000*10; // 1 second delay
248 }
249
250 /* Reset the monitoring */
252
253 /*
254 * Somebody released INBV display ownership, usually by invoking
255 * InbvNotifyDisplayOwnershipLost(). However the caller of this
256 * function certainly specified a different callback than ours.
257 * As we are going to be the only owner of the active display,
258 * we need to re-register our own display reset callback.
259 */
261
262 /* Tell Win32k to reset the display */
263 CallbackParams.CalloutType = VideoFindAdapterCallout;
264 // CallbackParams.PhysDisp = NULL;
265 CallbackParams.Param = (ULONG_PTR)TRUE; // TRUE: Re-enable display; FALSE: Disable display.
266 VideoPortWin32kCallout(&CallbackParams);
267 }
268
269 // FIXME: See IntVideoPortInbvCleanup().
270 // PsTerminateSystemThread(STATUS_SUCCESS);
271}
272
273static NTSTATUS
275{
276 /* Create the INBV monitoring thread if needed */
277 if (!InbvThreadHandle)
278 {
281
283 0,
285 NULL,
286 NULL,
288 NULL);
289 if (!NT_SUCCESS(Status))
291 }
292
293 /* Re-register the display reset callback with INBV */
295
296 return STATUS_SUCCESS;
297}
298
299static NTSTATUS
302{
303 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
304 // HANDLE ThreadHandle;
305
306 DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
307 if ((DeviceExtension->DeviceOpened >= 1) &&
308 (InterlockedDecrement((PLONG)&DeviceExtension->DeviceOpened) == 0))
309 {
310 // RemoveEntryList(&DeviceExtension->HwResetListEntry);
313 // or InbvAcquireDisplayOwnership(); ?
314 }
315
316#if 0
317 // TODO: Find the best way to communicate the request.
318 /* Signal the INBV monitoring thread and wait for it to terminate */
320 if (ThreadHandle)
321 {
323 /* Close its handle */
324 ObCloseHandle(ThreadHandle, KernelMode);
325 }
326#endif
327
328 return STATUS_SUCCESS;
329}
330
331
333NTAPI
337{
341
342 /* Get the initialization data we saved in VideoPortInitialize. */
344
345 /* Create adapter device object. */
349 DriverExtension->InitializationData.StartingDeviceNumber,
350 0,
351 &DeviceObject);
352 if (!NT_SUCCESS(Status))
353 {
354 ERR_(VIDEOPRT, "IntVideoPortCreateAdapterDeviceObject() failed with status 0x%lx\n", Status);
355 }
356 return Status;
357}
358
359/*
360 * IntVideoPortDispatchOpen
361 *
362 * Answer requests for Open calls.
363 *
364 * Run Level
365 * PASSIVE_LEVEL
366 */
368NTAPI
371 IN PIRP Irp)
372{
374 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
376
377 TRACE_(VIDEOPRT, "IntVideoPortDispatchOpen\n");
378
379 if (!CsrProcess)
380 {
381 /*
382 * We know the first open call will be from the CSRSS process
383 * to let us know its handle.
384 */
385 INFO_(VIDEOPRT, "Referencing CSRSS\n");
388 INFO_(VIDEOPRT, "CsrProcess 0x%p\n", CsrProcess);
389
391 if (!NT_SUCCESS(Status))
392 {
393 ERR_(VIDEOPRT, "IntInitializeVideoAddressSpace() failed: 0x%lx\n", Status);
396 return Status;
397 }
398 }
399
400 DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
401 DriverExtension = DeviceExtension->DriverExtension;
402
403 // FIXME: (Re-)initialize INBV only if DeviceObject doesn't belong to a mirror driver.
405
406 if (DriverExtension->InitializationData.HwInitialize(&DeviceExtension->MiniPortDeviceExtension))
407 {
409 InterlockedIncrement((PLONG)&DeviceExtension->DeviceOpened);
410
411 /* Query children, now that device is opened */
413 }
414 else
415 {
417 }
418
419 Irp->IoStatus.Status = Status;
420 Irp->IoStatus.Information = FILE_OPENED;
422
423 return Status;
424}
425
426/*
427 * IntVideoPortDispatchClose
428 *
429 * Answer requests for Close calls.
430 *
431 * Run Level
432 * PASSIVE_LEVEL
433 */
435NTAPI
438 IN PIRP Irp)
439{
440 TRACE_(VIDEOPRT, "IntVideoPortDispatchClose\n");
441
443
444 Irp->IoStatus.Status = STATUS_SUCCESS;
446 return STATUS_SUCCESS;
447}
448
449PSTR
451{
452 switch (Ioctl)
453 {
455 return "IOCTL_VIDEO_ENABLE_VDM"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x00, METHOD_BUFFERED, FILE_ANY_ACCESS)
457 return "IOCTL_VIDEO_DISABLE_VDM"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x01, METHOD_BUFFERED, FILE_ANY_ACCESS)
459 return "IOCTL_VIDEO_REGISTER_VDM"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x02, METHOD_BUFFERED, FILE_ANY_ACCESS)
461 return "IOCTL_VIDEO_SET_OUTPUT_DEVICE_POWER_STATE"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x03, METHOD_BUFFERED, FILE_ANY_ACCESS)
463 return "IOCTL_VIDEO_GET_OUTPUT_DEVICE_POWER_STATE"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x04, METHOD_BUFFERED, FILE_ANY_ACCESS)
465 return "IOCTL_VIDEO_MONITOR_DEVICE"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x05, METHOD_BUFFERED, FILE_ANY_ACCESS)
467 return "IOCTL_VIDEO_ENUM_MONITOR_PDO"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x06, METHOD_BUFFERED, FILE_ANY_ACCESS)
469 return "IOCTL_VIDEO_INIT_WIN32K_CALLBACKS"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x07, METHOD_BUFFERED, FILE_ANY_ACCESS)
471 return "IOCTL_VIDEO_HANDLE_VIDEOPARAMETERS"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x08, METHOD_BUFFERED, FILE_ANY_ACCESS)
473 return "IOCTL_VIDEO_IS_VGA_DEVICE"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x09, METHOD_BUFFERED, FILE_ANY_ACCESS)
475 return "IOCTL_VIDEO_USE_DEVICE_IN_SESSION"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x0a, METHOD_BUFFERED, FILE_ANY_ACCESS)
477 return "IOCTL_VIDEO_PREPARE_FOR_EARECOVERY"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x0b, METHOD_BUFFERED, FILE_ANY_ACCESS)
479 return "IOCTL_VIDEO_SAVE_HARDWARE_STATE"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x80, METHOD_BUFFERED, FILE_ANY_ACCESS)
481 return "IOCTL_VIDEO_RESTORE_HARDWARE_STATE"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x81, METHOD_BUFFERED, FILE_ANY_ACCESS)
483 return "IOCTL_VIDEO_QUERY_AVAIL_MODES"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x100, METHOD_BUFFERED, FILE_ANY_ACCESS)
485 return "IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x101, METHOD_BUFFERED, FILE_ANY_ACCESS)
487 return "IOCTL_VIDEO_QUERY_CURRENT_MODE"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x102, METHOD_BUFFERED, FILE_ANY_ACCESS)
489 return "IOCTL_VIDEO_SET_CURRENT_MODE"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x103, METHOD_BUFFERED, FILE_ANY_ACCESS)
491 return "IOCTL_VIDEO_RESET_DEVICE"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x104, METHOD_BUFFERED, FILE_ANY_ACCESS)
493 return "IOCTL_VIDEO_LOAD_AND_SET_FONT"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x105, METHOD_BUFFERED, FILE_ANY_ACCESS)
495 return "IOCTL_VIDEO_SET_PALETTE_REGISTERS"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x106, METHOD_BUFFERED, FILE_ANY_ACCESS)
497 return "IOCTL_VIDEO_SET_COLOR_REGISTERS"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x107, METHOD_BUFFERED, FILE_ANY_ACCESS)
499 return "IOCTL_VIDEO_ENABLE_CURSOR"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x108, METHOD_BUFFERED, FILE_ANY_ACCESS)
501 return "IOCTL_VIDEO_DISABLE_CURSOR"; // CTL_CODE (FILE_DEVICE_VIDEO, 0x109, METHOD_BUFFERED, FILE_ANY_ACCESS)
503 return "IOCTL_VIDEO_SET_CURSOR_ATTR"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x10a, METHOD_BUFFERED, FILE_ANY_ACCESS)
505 return "IOCTL_VIDEO_QUERY_CURSOR_ATTR"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x10b, METHOD_BUFFERED, FILE_ANY_ACCESS)
507 return "IOCTL_VIDEO_SET_CURSOR_POSITION"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x10c, METHOD_BUFFERED, FILE_ANY_ACCESS)
509 return "IOCTL_VIDEO_QUERY_CURSOR_POSITION"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x10d, METHOD_BUFFERED, FILE_ANY_ACCESS)
511 return "IOCTL_VIDEO_ENABLE_POINTER"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x10e, METHOD_BUFFERED, FILE_ANY_ACCESS)
513 return "IOCTL_VIDEO_DISABLE_POINTER"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x10f, METHOD_BUFFERED, FILE_ANY_ACCESS)
515 return "IOCTL_VIDEO_SET_POINTER_ATTR"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x110, METHOD_BUFFERED, FILE_ANY_ACCESS)
517 return "IOCTL_VIDEO_QUERY_POINTER_ATTR"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x111, METHOD_BUFFERED, FILE_ANY_ACCESS)
519 return "IOCTL_VIDEO_SET_POINTER_POSITION"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x112, METHOD_BUFFERED, FILE_ANY_ACCESS)
521 return "IOCTL_VIDEO_QUERY_POINTER_POSITION"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x113, METHOD_BUFFERED, FILE_ANY_ACCESS)
523 return "IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x114, METHOD_BUFFERED, FILE_ANY_ACCESS)
525 return "IOCTL_VIDEO_GET_BANK_SELECT_CODE"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x115, METHOD_BUFFERED, FILE_ANY_ACCESS)
527 return "IOCTL_VIDEO_MAP_VIDEO_MEMORY"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x116, METHOD_BUFFERED, FILE_ANY_ACCESS)
529 return "IOCTL_VIDEO_UNMAP_VIDEO_MEMORY"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x117, METHOD_BUFFERED, FILE_ANY_ACCESS)
531 return "IOCTL_VIDEO_QUERY_PUBLIC_ACCESS_RANGES"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x118, METHOD_BUFFERED, FILE_ANY_ACCESS)
533 return "IOCTL_VIDEO_FREE_PUBLIC_ACCESS_RANGES"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x119, METHOD_BUFFERED, FILE_ANY_ACCESS)
535 return "IOCTL_VIDEO_QUERY_COLOR_CAPABILITIES"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x11a, METHOD_BUFFERED, FILE_ANY_ACCESS)
537 return "IOCTL_VIDEO_SET_POWER_MANAGEMENT"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x11b, METHOD_BUFFERED, FILE_ANY_ACCESS)
539 return "IOCTL_VIDEO_GET_POWER_MANAGEMENT"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x11c, METHOD_BUFFERED, FILE_ANY_ACCESS)
541 return "IOCTL_VIDEO_SHARE_VIDEO_MEMORY"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x11d, METHOD_BUFFERED, FILE_ANY_ACCESS)
543 return "IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x11e, METHOD_BUFFERED, FILE_ANY_ACCESS)
545 return "IOCTL_VIDEO_SET_COLOR_LUT_DATA"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x11f, METHOD_BUFFERED, FILE_ANY_ACCESS)
547 return "IOCTL_VIDEO_GET_CHILD_STATE"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x120, METHOD_BUFFERED, FILE_ANY_ACCESS)
549 return "IOCTL_VIDEO_VALIDATE_CHILD_STATE_CONFIGURATION"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x121, METHOD_BUFFERED, FILE_ANY_ACCESS)
551 return "IOCTL_VIDEO_SET_CHILD_STATE_CONFIGURATION"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x122, METHOD_BUFFERED, FILE_ANY_ACCESS)
553 return "IOCTL_VIDEO_SWITCH_DUALVIEW"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x123, METHOD_BUFFERED, FILE_ANY_ACCESS)
555 return "IOCTL_VIDEO_SET_BANK_POSITION"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x124, METHOD_BUFFERED, FILE_ANY_ACCESS)
557 return "IOCTL_VIDEO_QUERY_SUPPORTED_BRIGHTNESS"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x125, METHOD_BUFFERED, FILE_ANY_ACCESS)
559 return "IOCTL_VIDEO_QUERY_DISPLAY_BRIGHTNESS"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x126, METHOD_BUFFERED, FILE_ANY_ACCESS)
561 return "IOCTL_VIDEO_SET_DISPLAY_BRIGHTNESS"; // CTL_CODE(FILE_DEVICE_VIDEO, 0x127, METHOD_BUFFERED, FILE_ANY_ACCESS)
562 }
563
564 return "<unknown ioctl code>";
565}
566
567static
574{
575 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
576
577 /* Check buffer size */
580 {
581 ERR_(VIDEOPRT, "Buffer too small for VIDEO_DEVICE_SESSION_STATUS: %lx\n",
584 }
585
586 /* Get the device extension */
587 DeviceExtension = DeviceObject->DeviceExtension;
588
589 /* Shall we enable the session? */
590 if (SessionState->bEnable)
591 {
592 /* Check if we have no session yet */
593 if (DeviceExtension->SessionId == -1)
594 {
595 /* Use this session and return success */
596 DeviceExtension->SessionId = PsGetCurrentProcessSessionId();
597 SessionState->bSuccess = TRUE;
598 }
599 else
600 {
601 ERR_(VIDEOPRT, "Requested to set session, but session is already set to: 0x%lx\n",
602 DeviceExtension->SessionId);
603 SessionState->bSuccess = FALSE;
604 }
605 }
606 else
607 {
608 /* Check if we belong to the current session */
609 if (DeviceExtension->SessionId == PsGetCurrentProcessSessionId())
610 {
611 /* Reset the session and return success */
612 DeviceExtension->SessionId = -1;
613 SessionState->bSuccess = TRUE;
614 }
615 else
616 {
617 ERR_(VIDEOPRT, "Requested to reset session, but session is not set\n");
618 SessionState->bSuccess = FALSE;
619 }
620 }
621
622 return STATUS_SUCCESS;
623}
624
625static
629 _Inout_ PVIDEO_WIN32K_CALLBACKS Win32kCallbacks,
632{
633 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
634
637 {
638 ERR_(VIDEOPRT, "Buffer too small for VIDEO_WIN32K_CALLBACKS: %lx\n",
641 }
642
643 /* Save the callout function globally */
644 Win32kCallout = Win32kCallbacks->Callout;
645
646 /* Return reasonable values to Win32k */
647 Win32kCallbacks->bACPI = FALSE;
648 Win32kCallbacks->pPhysDeviceObject = DeviceExtension->PhysicalDeviceObject;
649 Win32kCallbacks->DualviewFlags = 0;
650
651 return STATUS_SUCCESS;
652}
653
654static
658 IN PIRP Irp)
659{
660 PIO_STACK_LOCATION IrpStack;
662 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
664
665 TRACE_(VIDEOPRT, "VideoPortForwardDeviceControl\n");
666
668 DeviceExtension = DeviceObject->DeviceExtension;
669 DriverExtension = DeviceExtension->DriverExtension;
670
671 /* Translate the IRP to a VRP */
672 vrp.StatusBlock = (PSTATUS_BLOCK)&Irp->IoStatus;
673 vrp.IoControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;
674
675 INFO_(VIDEOPRT, "- IoControlCode: %x\n", vrp.IoControlCode);
676
677 /* We're assuming METHOD_BUFFERED */
678 vrp.InputBuffer = Irp->AssociatedIrp.SystemBuffer;
679 vrp.InputBufferLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength;
680 vrp.OutputBuffer = Irp->AssociatedIrp.SystemBuffer;
681 vrp.OutputBufferLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;
682
683 /* Call the Miniport Driver with the VRP */
684 DriverExtension->InitializationData.HwStartIO(&DeviceExtension->MiniPortDeviceExtension,
685 &vrp);
686
687 INFO_(VIDEOPRT, "- Returned status: %x\n", Irp->IoStatus.Status);
688
689 /* Map from win32 error codes to NT status values. */
690 switch (Irp->IoStatus.Status)
691 {
692 case NO_ERROR:
693 return STATUS_SUCCESS;
696 case ERROR_MORE_DATA:
706 case ERROR_IO_PENDING:
707 return STATUS_PENDING;
708 default:
709 return STATUS_UNSUCCESSFUL;
710 }
711}
712
713/*
714 * IntVideoPortDispatchDeviceControl
715 *
716 * Answer requests for device control calls.
717 *
718 * Run Level
719 * PASSIVE_LEVEL
720 */
722NTAPI
725 IN PIRP Irp)
726{
727 PIO_STACK_LOCATION IrpStack;
730
731 TRACE_(VIDEOPRT, "IntVideoPortDispatchDeviceControl\n");
732
734
735 switch (IrpStack->MajorFunction)
736 {
738 /* This is the main part of this function and is handled below */
739 break;
740
741 case IRP_MJ_SHUTDOWN:
742 {
743 /* Dereference CSRSS */
744 PKPROCESS OldCsrProcess;
745 OldCsrProcess = InterlockedExchangePointer((PVOID*)&CsrProcess, NULL);
746 if (OldCsrProcess)
747 ObDereferenceObject(OldCsrProcess);
748
749 Irp->IoStatus.Status = STATUS_SUCCESS;
751 return STATUS_SUCCESS;
752 }
753
754 default:
755 ERR_(VIDEOPRT, "- Unknown MajorFunction 0x%x\n", IrpStack->MajorFunction);
756 Irp->IoStatus.Status = STATUS_SUCCESS;
758 return STATUS_SUCCESS;
759 }
760
761 IoControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;
762
763 INFO_(VIDEOPRT, "- IoControlCode: 0x%x: %s\n", IoControlCode, IoctlName(IoControlCode));
764
765 switch (IoControlCode)
766 {
770 WARN_(VIDEOPRT, "- IOCTL_VIDEO_*_VDM are UNIMPLEMENTED!\n");
772 break;
773
776 WARN_(VIDEOPRT, "- IOCTL_VIDEO_GET/SET_OUTPUT_DEVICE_POWER_STATE are UNIMPLEMENTED!\n");
778 break;
779
782 WARN_(VIDEOPRT, "- IOCTL_VIDEO_GET/SET_POWER_MANAGEMENT are UNIMPLEMENTED!\n");
784 break;
785
789 WARN_(VIDEOPRT, "- IOCTL_VIDEO_*_BRIGHTNESS are UNIMPLEMENTED!\n");
791 break;
792
794 WARN_(VIDEOPRT, "- IOCTL_VIDEO_ENUM_MONITOR_PDO is UNIMPLEMENTED!\n");
796 break;
797
799 INFO_(VIDEOPRT, "- IOCTL_VIDEO_INIT_WIN32K_CALLBACKS\n");
801 Irp->AssociatedIrp.SystemBuffer,
802 IrpStack->Parameters.DeviceIoControl.InputBufferLength,
803 &Irp->IoStatus.Information);
804 break;
805
807 WARN_(VIDEOPRT, "- IOCTL_VIDEO_IS_VGA_DEVICE is UNIMPLEMENTED!\n");
809 break;
810
812 INFO_(VIDEOPRT, "- IOCTL_VIDEO_USE_DEVICE_IN_SESSION\n");
814 Irp->AssociatedIrp.SystemBuffer,
815 IrpStack->Parameters.DeviceIoControl.InputBufferLength,
816 &Irp->IoStatus.Information);
817 break;
818
820 INFO_(VIDEOPRT, "- IOCTL_VIDEO_PREPARE_FOR_EARECOVERY\n");
821 /*
822 * The Win32k Watchdog Timer detected that a thread spent more time
823 * in a display driver than the allotted time its threshold specified,
824 * and thus is going to attempt to recover by switching to VGA mode.
825 * If this attempt fails, the watchdog generates bugcheck 0xEA
826 * "THREAD_STUCK_IN_DEVICE_DRIVER".
827 *
828 * Prepare the recovery by resetting the display adapters to
829 * standard VGA 80x25 text mode.
830 */
833 break;
834
835 default:
836 /* Forward to the Miniport Driver */
838 break;
839 }
840
841 INFO_(VIDEOPRT, "- Returned status: 0x%x\n", Status);
842
843 Irp->IoStatus.Status = Status;
845 return Status;
846}
847
849NTAPI
852 IN PIRP Irp)
853{
857 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
859
860 /* Get the initialization data we saved in VideoPortInitialize.*/
861 DriverObject = DeviceObject->DriverObject;
863 DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
864
865 /* Store some resources in the DeviceExtension. */
866 AllocatedResources = Stack->Parameters.StartDevice.AllocatedResources;
868 {
872 ULONG ResourceListSize;
873
874 /* Save the resource list */
875 ResourceCount = AllocatedResources->List[0].PartialResourceList.Count;
876 ResourceListSize =
877 FIELD_OFFSET(CM_RESOURCE_LIST, List[0].PartialResourceList.
878 PartialDescriptors[ResourceCount]);
879 DeviceExtension->AllocatedResources = ExAllocatePool(PagedPool, ResourceListSize);
880 if (DeviceExtension->AllocatedResources == NULL)
881 {
883 }
884
885 RtlCopyMemory(DeviceExtension->AllocatedResources,
887 ResourceListSize);
888
889 /* Get the interrupt level/vector - needed by HwFindAdapter sometimes */
890 FullList = AllocatedResources->List;
891 ASSERT(AllocatedResources->Count == 1);
892 INFO_(VIDEOPRT, "InterfaceType %u BusNumber List %u Device BusNumber %u Version %u Revision %u\n",
893 FullList->InterfaceType, FullList->BusNumber, DeviceExtension->SystemIoBusNumber, FullList->PartialResourceList.Version, FullList->PartialResourceList.Revision);
894
895 /* FIXME: Is this ASSERT ok for resources from the PNP manager? */
896 ASSERT(FullList->InterfaceType == PCIBus);
897 ASSERT(FullList->BusNumber == DeviceExtension->SystemIoBusNumber);
898 ASSERT(1 == FullList->PartialResourceList.Version);
899 ASSERT(1 == FullList->PartialResourceList.Revision);
901 Descriptor < FullList->PartialResourceList.PartialDescriptors + FullList->PartialResourceList.Count;
902 Descriptor++)
903 {
905 {
906 DeviceExtension->InterruptLevel = Descriptor->u.Interrupt.Level;
907 DeviceExtension->InterruptVector = Descriptor->u.Interrupt.Vector;
908 if (Descriptor->ShareDisposition == CmResourceShareShared)
909 DeviceExtension->InterruptShared = TRUE;
910 else
911 DeviceExtension->InterruptShared = FALSE;
912 }
913 }
914 }
915
916 INFO_(VIDEOPRT, "Interrupt level: 0x%x Interrupt Vector: 0x%x\n",
917 DeviceExtension->InterruptLevel,
918 DeviceExtension->InterruptVector);
919
920 /* Create adapter device object. */
924}
925
926
928NTAPI
931 PIRP Irp,
933{
935
936 if (Irp->PendingReturned)
938
940}
941
943NTAPI
945{
946 PDEVICE_RELATIONS DeviceRelations;
947 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
948 PVIDEO_PORT_CHILD_EXTENSION ChildExtension;
949 ULONG i;
950 PLIST_ENTRY CurrentEntry;
952
953 if (InterlockedCompareExchange((PLONG)&DeviceExtension->DeviceOpened, 0, 0) == 0)
954 {
955 /* Device not opened. Don't enumerate children yet */
956 WARN_(VIDEOPRT, "Skipping child enumeration because device is not opened");
958 }
959 /* Query children of the device. */
961 if (!NT_SUCCESS(Status))
962 return Status;
963
964 /* Count the children */
965 i = 0;
966 CurrentEntry = DeviceExtension->ChildDeviceList.Flink;
967 while (CurrentEntry != &DeviceExtension->ChildDeviceList)
968 {
969 i++;
970 CurrentEntry = CurrentEntry->Flink;
971 }
972
973 if (i == 0)
974 return Irp->IoStatus.Status;
975
976 DeviceRelations = ExAllocatePool(PagedPool,
977 sizeof(DEVICE_RELATIONS) + ((i - 1) * sizeof(PVOID)));
978 if (!DeviceRelations) return STATUS_NO_MEMORY;
979
980 DeviceRelations->Count = i;
981
982 /* Add the children */
983 i = 0;
984 CurrentEntry = DeviceExtension->ChildDeviceList.Flink;
985 while (CurrentEntry != &DeviceExtension->ChildDeviceList)
986 {
987 ChildExtension = CONTAINING_RECORD(CurrentEntry, VIDEO_PORT_CHILD_EXTENSION, ListEntry);
988
990 DeviceRelations->Objects[i] = ChildExtension->PhysicalDeviceObject;
991
992 i++;
993 CurrentEntry = CurrentEntry->Flink;
994 }
995
996 INFO_(VIDEOPRT, "Reported %d PDOs\n", i);
997 Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
998
999 return STATUS_SUCCESS;
1000}
1001
1003NTAPI
1005{
1006 KEVENT Event;
1008 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension =
1010
1015 &Event,
1016 TRUE,
1017 TRUE,
1018 TRUE);
1019
1020 Status = IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
1021 if (Status == STATUS_PENDING)
1022 {
1024 Status = Irp->IoStatus.Status;
1025 }
1026
1027 return Status;
1028}
1029
1031NTAPI
1034 IN PIRP Irp)
1035{
1038 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
1039
1041
1042 switch (IrpSp->MinorFunction)
1043 {
1046 if (NT_SUCCESS(Status) && NT_SUCCESS(Irp->IoStatus.Status))
1048 Irp->IoStatus.Status = Status;
1049 Irp->IoStatus.Information = 0;
1051 break;
1052
1054 /* Call lower drivers, and ignore result (that's probably STATUS_NOT_SUPPORTED) */
1056 /* Now, fill resource requirements list */
1058 Irp->IoStatus.Status = Status;
1060 break;
1061
1064 {
1066 Status = IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
1067 }
1068 else
1069 {
1071 Irp->IoStatus.Status = Status;
1073 }
1074 break;
1075
1080
1081 case IRP_MN_STOP_DEVICE:
1083 if (NT_SUCCESS(Status) && NT_SUCCESS(Irp->IoStatus.Status))
1085 Irp->IoStatus.Status = Status;
1086 Irp->IoStatus.Information = 0;
1088 break;
1089
1093 Irp->IoStatus.Status = STATUS_SUCCESS;
1094 Irp->IoStatus.Information = 0;
1096 break;
1097
1098 default:
1099 Status = Irp->IoStatus.Status;
1101 break;
1102 }
1103
1104 return Status;
1105}
1106
1108NTAPI
1111 IN PIRP Irp)
1112{
1113 PVIDEO_PORT_COMMON_EXTENSION CommonExtension = DeviceObject->DeviceExtension;
1114
1115 if (CommonExtension->Fdo)
1117 else
1119}
1120
1122NTAPI
1125 IN PIRP Irp)
1126{
1127 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension;
1128
1129 DeviceExtension = DeviceObject->DeviceExtension;
1130 RtlFreeUnicodeString(&DeviceExtension->RegistryPath);
1131
1132 Irp->IoStatus.Status = STATUS_SUCCESS;
1133 Irp->IoStatus.Information = 0;
1135
1136 return STATUS_SUCCESS;
1137}
1138
1140NTAPI
1143 IN PIRP Irp)
1144{
1146 NTSTATUS Status = Irp->IoStatus.Status;
1147 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
1148
1150
1151 if (DeviceExtension->Common.Fdo)
1152 {
1155 return PoCallDriver(DeviceExtension->NextDeviceObject, Irp);
1156 }
1157 else
1158 {
1159 switch (IrpSp->MinorFunction)
1160 {
1161 case IRP_MN_QUERY_POWER:
1162 case IRP_MN_SET_POWER:
1164 break;
1165 }
1167 Irp->IoStatus.Status = Status;
1169 return Status;
1170 }
1171}
1172
1174NTAPI
1177 IN PIRP Irp)
1178{
1180 PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
1181
1182 if (DeviceExtension->Common.Fdo)
1183 {
1185 return IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
1186 }
1187 else
1188 {
1189 Status = Irp->IoStatus.Status;
1191 return Status;
1192 }
1193}
1194
1195VOID
1196NTAPI
1198{
1199}
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
unsigned char BOOLEAN
#define VOID
Definition: acefi.h:82
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
LONG NTSTATUS
Definition: precomp.h:26
static const COLUMN_LIST Columns[]
Definition: listview.c:19
PDEVICE_OBJECT PhysicalDeviceObject
Definition: btrfs_drv.h:1157
NTSTATUS NTAPI IntVideoPortDispatchPdoPnp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: child.c:386
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
_In_ PIRP Irp
Definition: csq.h:116
#define ERROR_DEV_NOT_EXIST
Definition: dderror.h:8
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define NO_ERROR
Definition: dderror.h:5
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
#define ERROR_IO_PENDING
Definition: dderror.h:15
#define ERROR_INVALID_FUNCTION
Definition: dderror.h:6
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define TRACE_(x)
Definition: compat.h:76
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4137
#define ULONG_PTR
Definition: config.h:101
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
#define KeDelayExecutionThread(mode, foo, t)
Definition: env_spec_w32.h:484
#define PagedPool
Definition: env_spec_w32.h:308
@ Success
Definition: eventcreate.c:712
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
_Must_inspect_result_ __in WDFIOTARGET __in_opt WDFREQUEST __in ULONG Ioctl
Status
Definition: gdiplustypes.h:25
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
#define KeGetCurrentThread
Definition: hal.h:55
@ PCIBus
Definition: hwresource.cpp:142
#define CmResourceTypeInterrupt
Definition: hwresource.cpp:124
VOID NTAPI InbvNotifyDisplayOwnershipLost(_In_ INBV_RESET_DISPLAY_PARAMETERS Callback)
Definition: inbv.c:404
BOOLEAN NTAPI InbvCheckDisplayOwnership(VOID)
Definition: inbv.c:316
static ULONG ResourceCount
Definition: inbv.c:50
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
#define LOW_REALTIME_PRIORITY
NTSTATUS NTAPI IntInitializeVideoAddressSpace(VOID)
Definition: int10.c:200
#define InterlockedCompareExchange
Definition: interlocked.h:104
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:490
if(dx< 0)
Definition: linetemp.h:194
#define ASSERT(a)
Definition: mode.c:44
#define _Inout_
Definition: ms_sal.h:378
#define _Out_
Definition: ms_sal.h:345
#define _In_
Definition: ms_sal.h:308
_Inout_opt_ PDEVICE_OBJECT _Inout_opt_ PDEVICE_OBJECT _Inout_opt_ PDEVICE_OBJECT _Inout_opt_ PCM_RESOURCE_LIST * AllocatedResources
Definition: ndis.h:4643
#define KernelMode
Definition: asm.h:34
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define FILE_OPENED
Definition: nt_native.h:769
#define IOCTL_VIDEO_SWITCH_DUALVIEW
Definition: ntddvdeo.h:245
#define IOCTL_VIDEO_SET_POWER_MANAGEMENT
Definition: ntddvdeo.h:239
#define IOCTL_VIDEO_SHARE_VIDEO_MEMORY
Definition: ntddvdeo.h:242
#define IOCTL_VIDEO_MAP_VIDEO_MEMORY
Definition: ntddvdeo.h:173
#define IOCTL_VIDEO_ENABLE_POINTER
Definition: ntddvdeo.h:155
#define IOCTL_VIDEO_IS_VGA_DEVICE
Definition: ntddvdeo.h:137
#define IOCTL_VIDEO_ENABLE_VDM
Definition: ntddvdeo.h:110
#define IOCTL_VIDEO_SET_PALETTE_REGISTERS
Definition: ntddvdeo.h:230
#define IOCTL_VIDEO_SET_POINTER_ATTR
Definition: ntddvdeo.h:233
#define IOCTL_VIDEO_UNMAP_VIDEO_MEMORY
Definition: ntddvdeo.h:248
#define IOCTL_VIDEO_HANDLE_VIDEOPARAMETERS
Definition: ntddvdeo.h:134
#define IOCTL_VIDEO_USE_DEVICE_IN_SESSION
Definition: ntddvdeo.h:140
#define IOCTL_VIDEO_QUERY_CURSOR_ATTR
Definition: ntddvdeo.h:185
VOID(NTAPI * PVIDEO_WIN32K_CALLOUT)(_In_ PVOID Params)
Definition: ntddvdeo.h:327
#define IOCTL_VIDEO_QUERY_CURSOR_POSITION
Definition: ntddvdeo.h:188
#define IOCTL_VIDEO_SET_CURSOR_POSITION
Definition: ntddvdeo.h:227
#define IOCTL_VIDEO_QUERY_CURRENT_MODE
Definition: ntddvdeo.h:182
@ VideoFindAdapterCallout
Definition: ntddvdeo.h:296
#define IOCTL_VIDEO_SET_BANK_POSITION
Definition: ntddvdeo.h:260
#define IOCTL_VIDEO_MONITOR_DEVICE
Definition: ntddvdeo.h:125
#define IOCTL_VIDEO_ENABLE_CURSOR
Definition: ntddvdeo.h:152
#define IOCTL_VIDEO_DISABLE_CURSOR
Definition: ntddvdeo.h:146
#define IOCTL_VIDEO_GET_CHILD_STATE
Definition: ntddvdeo.h:164
#define IOCTL_VIDEO_GET_POWER_MANAGEMENT
Definition: ntddvdeo.h:167
#define IOCTL_VIDEO_SET_POINTER_POSITION
Definition: ntddvdeo.h:236
#define IOCTL_VIDEO_QUERY_DISPLAY_BRIGHTNESS
Definition: ntddvdeo.h:266
#define IOCTL_VIDEO_SET_CURRENT_MODE
Definition: ntddvdeo.h:221
#define IOCTL_VIDEO_SET_DISPLAY_BRIGHTNESS
Definition: ntddvdeo.h:269
#define IOCTL_VIDEO_FREE_PUBLIC_ACCESS_RANGES
Definition: ntddvdeo.h:158
#define IOCTL_VIDEO_GET_BANK_SELECT_CODE
Definition: ntddvdeo.h:161
#define IOCTL_VIDEO_PREPARE_FOR_EARECOVERY
Definition: ntddvdeo.h:143
#define IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES
Definition: ntddvdeo.h:197
#define IOCTL_VIDEO_SET_COLOR_REGISTERS
Definition: ntddvdeo.h:218
#define IOCTL_VIDEO_VALIDATE_CHILD_STATE_CONFIGURATION
Definition: ntddvdeo.h:257
#define IOCTL_VIDEO_SET_COLOR_LUT_DATA
Definition: ntddvdeo.h:254
#define IOCTL_VIDEO_LOAD_AND_SET_FONT
Definition: ntddvdeo.h:170
#define IOCTL_VIDEO_RESET_DEVICE
Definition: ntddvdeo.h:206
#define IOCTL_VIDEO_QUERY_POINTER_POSITION
Definition: ntddvdeo.h:200
#define IOCTL_VIDEO_SET_CURSOR_ATTR
Definition: ntddvdeo.h:224
struct _VIDEO_WIN32K_CALLBACKS VIDEO_WIN32K_CALLBACKS
struct _VIDEO_DEVICE_SESSION_STATUS VIDEO_DEVICE_SESSION_STATUS
#define IOCTL_VIDEO_SET_CHILD_STATE_CONFIGURATION
Definition: ntddvdeo.h:215
#define IOCTL_VIDEO_DISABLE_VDM
Definition: ntddvdeo.h:113
#define IOCTL_VIDEO_DISABLE_POINTER
Definition: ntddvdeo.h:149
#define IOCTL_VIDEO_GET_OUTPUT_DEVICE_POWER_STATE
Definition: ntddvdeo.h:122
#define IOCTL_VIDEO_REGISTER_VDM
Definition: ntddvdeo.h:116
#define IOCTL_VIDEO_QUERY_POINTER_ATTR
Definition: ntddvdeo.h:194
#define IOCTL_VIDEO_ENUM_MONITOR_PDO
Definition: ntddvdeo.h:128
#define IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY
Definition: ntddvdeo.h:251
#define IOCTL_VIDEO_SET_OUTPUT_DEVICE_POWER_STATE
Definition: ntddvdeo.h:119
#define IOCTL_VIDEO_QUERY_AVAIL_MODES
Definition: ntddvdeo.h:176
#define IOCTL_VIDEO_INIT_WIN32K_CALLBACKS
Definition: ntddvdeo.h:131
#define IOCTL_VIDEO_QUERY_COLOR_CAPABILITIES
Definition: ntddvdeo.h:179
#define IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES
Definition: ntddvdeo.h:191
#define IOCTL_VIDEO_SAVE_HARDWARE_STATE
Definition: ntddvdeo.h:212
#define IOCTL_VIDEO_QUERY_SUPPORTED_BRIGHTNESS
Definition: ntddvdeo.h:263
#define IOCTL_VIDEO_RESTORE_HARDWARE_STATE
Definition: ntddvdeo.h:209
#define IOCTL_VIDEO_QUERY_PUBLIC_ACCESS_RANGES
Definition: ntddvdeo.h:203
@ NotificationEvent
#define RTL_CONSTANT_OBJECT_ATTRIBUTES(n, a)
#define IRP_MN_SURPRISE_REMOVAL
Definition: ntifs_ex.h:408
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421
#define IoCopyCurrentIrpStackLocationToNext(Irp)
Definition: ntifs_ex.h:413
PVOID NTAPI IoGetDriverObjectExtension(IN PDRIVER_OBJECT DriverObject, IN PVOID ClientIdentificationAddress)
Definition: driver.c:1904
#define IoCompleteRequest
Definition: irp.c:1240
#define IoCallDriver
Definition: irp.c:1225
BOOLEAN FASTCALL KeTestSpinLock(IN PKSPIN_LOCK SpinLock)
Definition: spinlock.c:475
VOID NTAPI PoStartNextPowerIrp(IN PIRP Irp)
Definition: power.c:758
ULONG NTAPI PsGetCurrentProcessSessionId(VOID)
Definition: process.c:1133
NTSTATUS NTAPI PsCreateSystemThread(OUT PHANDLE ThreadHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN HANDLE ProcessHandle, IN PCLIENT_ID ClientId, IN PKSTART_ROUTINE StartRoutine, IN PVOID StartContext)
Definition: thread.c:602
#define STATUS_PENDING
Definition: ntstatus.h:82
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
#define STATUS_DEVICE_DOES_NOT_EXIST
Definition: ntstatus.h:428
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3379
PPCI_DRIVER_EXTENSION DriverExtension
Definition: pci.c:31
unsigned short USHORT
Definition: pedump.c:61
VOID NTAPI KeDetachProcess(VOID)
Definition: procobj.c:621
VOID NTAPI KeAttachProcess(IN PKPROCESS Process)
Definition: procobj.c:582
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:162
#define IRP_MJ_DEVICE_CONTROL
Definition: rdpdr.c:52
VPAPI VP_STATUS NTAPI VideoPortEnumerateChildren(IN PVOID HwDeviceExtension, IN PVOID Reserved)
Definition: videoprt.c:1444
struct _STATUS_BLOCK * PSTATUS_BLOCK
#define INFO_(ch,...)
Definition: debug.h:159
#define ERR_(ch,...)
Definition: debug.h:156
#define WARN_(ch,...)
Definition: debug.h:157
#define KeAcquireSpinLockAtDpcLevel(SpinLock)
Definition: ke.h:125
#define KeReleaseSpinLockFromDpcLevel(SpinLock)
Definition: ke.h:135
#define STATUS_MORE_PROCESSING_REQUIRED
Definition: shellext.h:68
#define STATUS_SUCCESS
Definition: shellext.h:65
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
base of all file and directory entries
Definition: entries.h:83
CM_PARTIAL_RESOURCE_LIST PartialResourceList
Definition: hwresource.cpp:160
CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1]
Definition: hwresource.cpp:119
PDEVICE_OBJECT Objects[1]
Definition: iotypes.h:2163
struct _IO_STACK_LOCATION::@1564::@1565 DeviceIoControl
union _IO_STACK_LOCATION::@1564 Parameters
struct _IO_STACK_LOCATION::@3978::@4003 QueryDeviceRelations
Definition: typedefs.h:120
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
PDEVICE_OBJECT PhysicalDeviceObject
Definition: videoprt.h:127
PDEVICE_OBJECT PhysicalDeviceObject
Definition: videoprt.h:87
PCM_RESOURCE_LIST AllocatedResources
Definition: videoprt.h:94
PDEVICE_OBJECT NextDeviceObject
Definition: videoprt.h:89
VIDEO_PORT_DRIVER_EXTENSION * DriverExtension
Definition: videoprt.h:103
CHAR POINTER_ALIGNMENT MiniPortDeviceExtension[1]
Definition: videoprt.h:113
UNICODE_STRING RegistryPath
Definition: videoprt.h:90
VIDEO_PORT_COMMON_EXTENSION Common
Definition: videoprt.h:84
ULONG InputBufferLength
Definition: video.h:333
PSTATUS_BLOCK StatusBlock
Definition: video.h:331
ULONG OutputBufferLength
Definition: video.h:335
VIDEO_WIN32K_CALLBACKS_PARAMS_TYPE CalloutType
Definition: ntddvdeo.h:319
KPRIORITY NTAPI KeSetPriorityThread(IN PKTHREAD Thread, IN KPRIORITY Priority)
Definition: thrdobj.c:1319
uint32_t * PULONG_PTR
Definition: typedefs.h:65
char * PSTR
Definition: typedefs.h:51
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
int64_t LONGLONG
Definition: typedefs.h:68
#define NTAPI
Definition: typedefs.h:36
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
int32_t * PLONG
Definition: typedefs.h:58
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
LONGLONG QuadPart
Definition: typedefs.h:114
PKPROCESS CsrProcess
Definition: videoprt.c:39
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:159
NTSTATUS NTAPI IntVideoPortFindAdapter(IN PDRIVER_OBJECT DriverObject, IN PVIDEO_PORT_DRIVER_EXTENSION DriverExtension, IN PDEVICE_OBJECT DeviceObject)
Definition: videoprt.c:414
KSPIN_LOCK HwResetAdaptersLock
Definition: videoprt.c:43
NTSTATUS NTAPI IntVideoPortEnumerateChildren(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: videoprt.c:1280
LIST_ENTRY HwResetAdaptersList
struct _VIDEO_PORT_DEVICE_EXTENSTION * PVIDEO_PORT_DEVICE_EXTENSION
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG BufferLength
Definition: wdfdevice.h:3771
_Must_inspect_result_ _In_ PDRIVER_OBJECT DriverObject
Definition: wdfdriver.h:213
_Must_inspect_result_ _In_ WDFDEVICE Fdo
Definition: wdffdo.h:461
_In_ WDFREQUEST _In_ size_t _In_ size_t _In_ ULONG IoControlCode
Definition: wdfio.h:325
_In_ WDFREQUEST _In_ PIO_STACK_LOCATION Stack
Definition: wdfrequest.h:639
_In_ WDFREQUEST _In_ NTSTATUS _In_ ULONG_PTR Information
Definition: wdfrequest.h:1049
_Must_inspect_result_ _In_ WDFIORESLIST _In_ PIO_RESOURCE_DESCRIPTOR Descriptor
Definition: wdfresource.h:342
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
struct _KPROCESS * PKPROCESS
Definition: wdm.template.h:201
NTSTATUS NTAPI IntVideoPortDispatchClose(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:436
NTSTATUS NTAPI IntVideoPortForwardIrpAndWait(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: dispatch.c:1004
static BOOLEAN InbvMonitoring
Definition: dispatch.c:35
NTSTATUS NTAPI IntVideoPortDispatchCleanup(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:1123
static BOOLEAN NTAPI IntVideoPortResetDisplayParametersEx(_In_ ULONG Columns, _In_ ULONG Rows, _In_ BOOLEAN CalledByInbv)
Definition: dispatch.c:72
NTSTATUS NTAPI IntVideoPortQueryBusRelations(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: dispatch.c:944
VOID NTAPI IntVideoPortUnload(PDRIVER_OBJECT DriverObject)
Definition: dispatch.c:1197
NTSTATUS NTAPI IntVideoPortForwardIrpAndWaitCompletionRoutine(PDEVICE_OBJECT Fdo, PIRP Irp, PVOID Context)
Definition: dispatch.c:929
NTSTATUS NTAPI IntVideoPortDispatchOpen(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:369
NTSTATUS NTAPI IntVideoPortDispatchDeviceControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:723
NTSTATUS NTAPI IntVideoPortDispatchFdoPnp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:1032
NTSTATUS NTAPI IntVideoPortDispatchSystemControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:1175
PSTR IoctlName(ULONG Ioctl)
Definition: dispatch.c:450
static NTSTATUS VideoPortForwardDeviceControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:656
static VOID VideoPortWin32kCallout(_In_ PVIDEO_WIN32K_CALLBACKS_PARAMS CallbackParams)
Definition: dispatch.c:40
static NTSTATUS VideoPortUseDeviceInSession(_Inout_ PDEVICE_OBJECT DeviceObject, _Inout_ PVIDEO_DEVICE_SESSION_STATUS SessionState, _In_ ULONG BufferLength, _Out_ PULONG_PTR Information)
Definition: dispatch.c:569
NTSTATUS NTAPI IntVideoPortDispatchPnp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:1109
static VOID NTAPI InbvMonitorThread(_In_ PVOID Context)
Definition: dispatch.c:208
NTSTATUS NTAPI IntVideoPortPnPStartDevice(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:850
static PVIDEO_WIN32K_CALLOUT Win32kCallout
Definition: dispatch.c:33
static BOOLEAN NTAPI IntVideoPortResetDisplayParameters(ULONG Columns, ULONG Rows)
Definition: dispatch.c:168
static NTSTATUS IntVideoPortInbvCleanup(IN PDEVICE_OBJECT DeviceObject)
Definition: dispatch.c:300
static NTSTATUS VideoPortInitWin32kCallbacks(_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PVIDEO_WIN32K_CALLBACKS Win32kCallbacks, _In_ ULONG BufferLength, _Out_ PULONG_PTR Information)
Definition: dispatch.c:627
NTSTATUS NTAPI IntVideoPortAddDevice(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject)
Definition: dispatch.c:334
static NTSTATUS IntVideoPortInbvInitialize(VOID)
Definition: dispatch.c:274
static HANDLE InbvThreadHandle
Definition: dispatch.c:34
NTSTATUS NTAPI IntVideoPortDispatchPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: dispatch.c:1141
NTSTATUS NTAPI IntVideoPortFilterResourceRequirements(IN PDEVICE_OBJECT DeviceObject, IN PIO_STACK_LOCATION IrpStack, IN PIRP Irp)
Definition: resource.c:77
@ CmResourceShareShared
Definition: cmtypes.h:243
_In_ ULONG Rows
Definition: haltypes.h:7
#define IRP_MN_CANCEL_STOP_DEVICE
@ BusRelations
Definition: iotypes.h:2152
#define IO_NO_INCREMENT
Definition: iotypes.h:598
#define IRP_MN_START_DEVICE
#define IRP_MN_REMOVE_DEVICE
#define IRP_MN_FILTER_RESOURCE_REQUIREMENTS
#define IRP_MN_QUERY_DEVICE_RELATIONS
#define IRP_MN_QUERY_STOP_DEVICE
#define IRP_MN_SET_POWER
#define IRP_MN_CANCEL_REMOVE_DEVICE
#define IRP_MN_STOP_DEVICE
#define IRP_MJ_SHUTDOWN
#define IO_VIDEO_INCREMENT
Definition: iotypes.h:609
#define IRP_MN_QUERY_POWER
#define IRP_MN_QUERY_REMOVE_DEVICE
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778
@ Executive
Definition: ketypes.h:415
#define ObDereferenceObject
Definition: obfuncs.h:203
#define ObReferenceObject
Definition: obfuncs.h:204
#define PsGetCurrentProcess
Definition: psfuncs.h:17