archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/drivers/video/ms/port/acpi.c

1172 lines
32 KiB
Raw Blame History

/*++
Copyright (c) 1990-2000 Microsoft Corporation
Module Name:
pnp.c
Abstract:
This is the pnp portion of the video port driver.
Environment:
kernel mode only
Revision History:
--*/
#include "videoprt.h"
#pragma alloc_text(PAGE,pVideoPortQueryACPIInterface)
#pragma alloc_text(PAGE,pVideoPortACPIEventHandler)
#pragma alloc_text(PAGE,pVideoPortACPIIoctl)
#pragma alloc_text(PAGE,VpRegisterLCDCallbacks)
#pragma alloc_text(PAGE,VpUnregisterLCDCallbacks)
#pragma alloc_text(PAGE,VpRegisterPowerStateCallback)
#pragma alloc_text(PAGE,VpDelayedPowerStateCallback)
#pragma alloc_text(PAGE,VpSetLCDPowerUsage)
BOOLEAN
pCheckDeviceRelations(
PFDO_EXTENSION FdoExtension,
BOOLEAN bNewMonitor
);
NTSTATUS
pVideoPortQueryACPIInterface(
PDEVICE_SPECIFIC_EXTENSION DoSpecificExtension
)
/*++
Routine Description:
Send a QueryInterface Irp to our parent (the PCI bus driver) to
retrieve the AGP_BUS_INTERFACE.
Returns:
NT_STATUS code
--*/
{
KEVENT Event;
PIRP QueryIrp = NULL;
IO_STATUS_BLOCK IoStatusBlock;
PIO_STACK_LOCATION NextStack;
NTSTATUS Status;
ACPI_INTERFACE_STANDARD AcpiInterface;
PFDO_EXTENSION FdoExtension = DoSpecificExtension->pFdoExtension;
//
// For those special cases, don't use ACPI HotKey switching
//
if (VpSetupTypeAtBoot != SETUPTYPE_NONE) {
return STATUS_INVALID_PARAMETER;
}
if (FdoExtension->Flags & LEGACY_DETECT) {
return STATUS_INVALID_PARAMETER;
}
if ((FdoExtension->Flags & FINDADAPTER_SUCCEEDED) == 0) {
return STATUS_INVALID_PARAMETER;
}
KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
QueryIrp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP,
FdoExtension->AttachedDeviceObject,
NULL,
0,
NULL,
&Event,
&IoStatusBlock);
if (QueryIrp == NULL) {
return STATUS_INVALID_PARAMETER;
}
//
// Set the default error code.
//
QueryIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
//
// Set up for a QueryInterface Irp.
//
NextStack = IoGetNextIrpStackLocation(QueryIrp);
NextStack->MajorFunction = IRP_MJ_PNP;
NextStack->MinorFunction = IRP_MN_QUERY_INTERFACE;
NextStack->Parameters.QueryInterface.InterfaceType = &GUID_ACPI_INTERFACE_STANDARD;
NextStack->Parameters.QueryInterface.Size = sizeof(ACPI_INTERFACE_STANDARD);
NextStack->Parameters.QueryInterface.Version = 1;
NextStack->Parameters.QueryInterface.Interface = (PINTERFACE) &AcpiInterface;
NextStack->Parameters.QueryInterface.InterfaceSpecificData = NULL;
AcpiInterface.Size = sizeof(ACPI_INTERFACE_STANDARD);
AcpiInterface.Version = 1;
//
// Call the filter driver.
//
Status = IoCallDriver(FdoExtension->AttachedDeviceObject, QueryIrp);
if (Status == STATUS_PENDING) {
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
Status = IoStatusBlock.Status;
}
if (NT_SUCCESS(Status))
{
pVideoDebugPrint((0, "VideoPort: This is an ACPI Machine !\n"));
//
// Let's register for this event and provide our default handler.
//
AcpiInterface.RegisterForDeviceNotifications(AcpiInterface.Context, //FdoExtension->AttachedDeviceObject,
pVideoPortACPIEventCallback,
DoSpecificExtension);
//
// Register for LCD notifications
//
VpRegisterLCDCallbacks();
}
//
// Turn on HotKey switching notify mode
//
if (NT_SUCCESS(Status))
{
ULONG active = 0;
UCHAR outputBuffer[sizeof(ACPI_EVAL_OUTPUT_BUFFER) + 10];
Status = pVideoPortACPIIoctl(FdoExtension->AttachedDeviceObject,
(ULONG) ('SOD_'),
&active,
NULL,
0,
(PACPI_EVAL_OUTPUT_BUFFER)outputBuffer);
}
//
// Register Dock/Undock notification
//
if (NT_SUCCESS(Status))
{
Status = IoRegisterPlugPlayNotification(EventCategoryHardwareProfileChange,
0,
NULL,
FdoExtension->FunctionalDeviceObject->DriverObject,
pVideoPortDockEventCallback,
DoSpecificExtension,
&DockCallbackHandle);
}
return Status;
}
NTSTATUS
pVideoPortDockEventCallback (
PVOID NotificationStructure,
PDEVICE_SPECIFIC_EXTENSION DoSpecificExtension
)
{
UNREFERENCED_PARAMETER(NotificationStructure);
pVideoPortACPIEventCallback(DoSpecificExtension, 0x77);
return STATUS_SUCCESS;
}
VOID
pVideoPortACPIEventCallback(
PDEVICE_SPECIFIC_EXTENSION DoSpecificExtension,
ULONG eventID
)
/*++
Routine Description:
Event notification callback for panel switching
NOTE This routine is not pageable as it is called from DPC level by
the ACPI BIOS.
--*/
{
PVIDEO_ACPI_EVENT_CONTEXT pContext;
//
// There are some cases the BIOS send the notofication even before the device is opened
//
if (!DoSpecificExtension->DeviceOpened)
return;
if (InterlockedIncrement(&(DoSpecificExtension->AcpiVideoEventsOutstanding)) < 2) {
// Queue work item
pContext = ExAllocatePoolWithTag(NonPagedPool,
sizeof(VIDEO_ACPI_EVENT_CONTEXT),
VP_TAG);
if (pContext && (eventID == 0x80 || eventID == 0x81 || eventID == 0x90 || eventID == 0x77))
{
pContext->DoSpecificExtension = DoSpecificExtension;
pContext->EventID = eventID;
ExInitializeWorkItem(&(pContext->workItem),
pVideoPortACPIEventHandler,
pContext);
ExQueueWorkItem(&(pContext->workItem), DelayedWorkQueue);
}
}
else
{
// We're getting a Notify storm, and we already have a work item on the job.
InterlockedDecrement(&(DoSpecificExtension->AcpiVideoEventsOutstanding));
}
return;
}
VOID
pVideoPortACPIEventHandler(
PVIDEO_ACPI_EVENT_CONTEXT EventContext
)
/*++
Routine Description:
Event handler for panel switching
--*/
{
UCHAR outputBuffer[0x200 + sizeof(ACPI_EVAL_OUTPUT_BUFFER)];
PCHILD_PDO_EXTENSION pChildDeviceExtension;
PDEVICE_OBJECT AttachedDeviceObject;
PDEVICE_OBJECT pChildPdos[10];
ULONG active, szChildIDs, i, AllowSwitch = 0, Switched = 0;
PVIDEO_CHILD_STATE_CONFIGURATION pChildIDs;
NTSTATUS Status;
BOOLEAN bNewMonitor;
VIDEO_WIN32K_CALLBACKS_PARAMS calloutParams;
PFDO_EXTENSION FdoExtension;
FdoExtension = EventContext->DoSpecificExtension->pFdoExtension;
ASSERT (FdoExtension != NULL);
pVideoDebugPrint((1, "pVideoPortACPIEventHandler: Event %08lx trigerred!\n",
EventContext->EventID));
AttachedDeviceObject = FdoExtension->AttachedDeviceObject;
if (FdoExtension->DevicePowerState != PowerDeviceD0)
{
EventContext->DoSpecificExtension->CachedEventID = EventContext->EventID;
goto ExitACPIEventHandler;
}
else
{
EventContext->DoSpecificExtension->CachedEventID = 0;
}
//
// Dock/Undock event handling
//
if (EventContext->EventID == 0x77)
{
calloutParams.CalloutType = VideoDisplaySwitchCallout;
calloutParams.PhysDisp = EventContext->DoSpecificExtension->PhysDisp;
calloutParams.Param = (ULONG_PTR)NULL;
VpWin32kCallout(&calloutParams);
goto ExitACPIEventHandler;
}
//
// Disable BIOS notification
//
active = 2;
pVideoPortACPIIoctl(AttachedDeviceObject,
(ULONG) ('SOD_'),
&active,
NULL,
0,
(PACPI_EVAL_OUTPUT_BUFFER)outputBuffer);
if (EventContext->EventID == 0x90)
{
calloutParams.CalloutType = VideoWakeupCallout;
VpWin32kCallout(&calloutParams);
}
else
{
szChildIDs = sizeof(VIDEO_CHILD_STATE_CONFIGURATION) + FdoExtension->ChildPdoNumber*sizeof(VIDEO_CHILD_STATE);
pChildIDs = (PVIDEO_CHILD_STATE_CONFIGURATION)ExAllocatePoolWithTag(PagedPool,
szChildIDs,
VP_TAG);
if (pChildIDs != NULL)
{
//
// During switching, no PnP action is allowed
//
ACQUIRE_DEVICE_LOCK (FdoExtension);
pChildIDs->Count = 0;
for (pChildDeviceExtension = FdoExtension->ChildPdoList;
pChildDeviceExtension != NULL;
pChildDeviceExtension = pChildDeviceExtension->NextChild
)
{
if ((!pChildDeviceExtension->bIsEnumerated) ||
pChildDeviceExtension->VideoChildDescriptor->Type != Monitor)
{
continue;
}
pChildIDs->ChildStateArray[pChildIDs->Count].Id = pChildDeviceExtension->VideoChildDescriptor->UId;
pChildIDs->ChildStateArray[pChildIDs->Count].State = 0;
pChildPdos[pChildIDs->Count] = pChildDeviceExtension->ChildDeviceObject;
Status = pVideoPortACPIIoctl(
IoGetAttachedDevice(pChildDeviceExtension->ChildDeviceObject),
(ULONG) ('SGD_'),
NULL,
NULL,
sizeof(ACPI_EVAL_OUTPUT_BUFFER)+0x10,
(PACPI_EVAL_OUTPUT_BUFFER)outputBuffer);
if (NT_SUCCESS(Status))
{
ASSERT(((PACPI_EVAL_OUTPUT_BUFFER)outputBuffer)->Argument[0].Type == ACPI_METHOD_ARGUMENT_INTEGER);
ASSERT(((PACPI_EVAL_OUTPUT_BUFFER)outputBuffer)->Argument[0].DataLength == sizeof(ULONG));
if (((PACPI_EVAL_OUTPUT_BUFFER)outputBuffer)->Argument[0].Argument)
{
pChildIDs->ChildStateArray[pChildIDs->Count].State = 1;
}
}
pChildIDs->Count++;
}
szChildIDs = sizeof(VIDEO_CHILD_STATE_CONFIGURATION) + pChildIDs->Count*sizeof(VIDEO_CHILD_STATE);
//
// Notify Miniport that display switching is about to happen.
// Treat the switch is allowed by default.
//
AllowSwitch = 1;
pVideoMiniDeviceIoControl(FdoExtension->FunctionalDeviceObject,
IOCTL_VIDEO_VALIDATE_CHILD_STATE_CONFIGURATION,
(PVOID)pChildIDs,
szChildIDs,
&AllowSwitch,
sizeof(ULONG));
//
// If Miniport says it's OK to proceed
//
if (AllowSwitch != 0)
{
//
// Check the Miniport do the switching for us
//
Status = pVideoMiniDeviceIoControl(FdoExtension->FunctionalDeviceObject,
IOCTL_VIDEO_SET_CHILD_STATE_CONFIGURATION,
(PVOID)pChildIDs,
szChildIDs,
NULL,
0);
if (NT_SUCCESS(Status))
{
pVideoDebugPrint((1, "VideoPort: Moniport does the switch!\n"));
Switched = 1;
}
}
//
// The last _DSS needs to commit the switching
//
if (pChildIDs->Count > 0)
{
pChildIDs->ChildStateArray[pChildIDs->Count-1].State |= 0x80000000;
}
for (i = 0; i < pChildIDs->Count; i++)
{
//
// If Miniport doesn't like to proceed or it does the switching already, just notify BIOS to go to next _DGS state
//
// Found some bad BIOS(Toshiba). They do switch anyway regardless of 0x40000000 bit. This has extremely bad effect
// on DualView
//
if (!AllowSwitch)
continue;
if (Switched)
{
pChildIDs->ChildStateArray[i].State |= 0x40000000;
}
pVideoPortACPIIoctl(IoGetAttachedDevice(pChildPdos[i]),
(ULONG) ('SSD_'),
&pChildIDs->ChildStateArray[i].State,
NULL,
0,
(PACPI_EVAL_OUTPUT_BUFFER)outputBuffer);
}
RELEASE_DEVICE_LOCK (FdoExtension);
ExFreePool(pChildIDs);
}
//
// On switching displays, call GDI / USER to tell the device to rebuild mode list
// and change current mode if neccesary
//
pVideoDebugPrint((0, "VideoPrt.sys: Display switching occured - calling GDI to rebuild mode table.\n"));
calloutParams.CalloutType = VideoDisplaySwitchCallout;
calloutParams.PhysDisp = (AllowSwitch) ? EventContext->DoSpecificExtension->PhysDisp : NULL;
//
// On Monitor changing, we receive Notify(81)
// On waking up from hibernation, we receive Notify(90)
// We also make IoInvalidateDeviceRelation happen inside Callout routine
//
bNewMonitor = (EventContext->EventID == 0x81);
ACQUIRE_DEVICE_LOCK (FdoExtension);
if (pCheckDeviceRelations(FdoExtension, bNewMonitor) )
{
calloutParams.Param = (ULONG_PTR)FdoExtension->PhysicalDeviceObject;
}
else
{
calloutParams.Param = (ULONG_PTR)NULL;
}
RELEASE_DEVICE_LOCK (FdoExtension);
VpWin32kCallout(&calloutParams);
}
ExitACPIEventHandler:
//
// Reenable BIOS notification
//
active = 0;
pVideoPortACPIIoctl(AttachedDeviceObject,
(ULONG) ('SOD_'),
&active,
NULL,
0,
(PACPI_EVAL_OUTPUT_BUFFER)outputBuffer);
InterlockedDecrement(&(EventContext->DoSpecificExtension->AcpiVideoEventsOutstanding));
//
// This also ends up freeing the work item as it's embedded in the context.
//
ExFreePool(EventContext);
return;
}
NTSTATUS
pVideoPortACPIIoctl(
IN PDEVICE_OBJECT DeviceObject,
IN ULONG MethodName,
IN PULONG InputParam1,
IN PULONG InputParam2,
IN ULONG OutputBufferSize,
IN PACPI_EVAL_OUTPUT_BUFFER pOutputBuffer
)
/*++
Routine Description:
Called to send a request to the DeviceObject
Arguments:
DeviceObject - The request is sent to this device object
MethodName - Name of the method to be run in ACPI space
pArgumets - Pointer that will receive the address of the ACPI data
Return Value:
NT Status of the operation
--*/
{
UCHAR buffer[sizeof(ACPI_EVAL_INPUT_BUFFER_COMPLEX) +
sizeof(ACPI_METHOD_ARGUMENT)];
PACPI_EVAL_INPUT_BUFFER_COMPLEX pInputBuffer;
ULONG size;
IO_STATUS_BLOCK ioBlock;
KEVENT event;
NTSTATUS status;
PIRP irp;
pVideoDebugPrint((2, "Call ACPI method %c%c%c%c!\n",
*((PUCHAR)&MethodName), *((PUCHAR)&MethodName+1),
*((PUCHAR)&MethodName+2), *((PUCHAR)&MethodName+3) ));
pInputBuffer = (PACPI_EVAL_INPUT_BUFFER_COMPLEX) buffer;
pInputBuffer->MethodNameAsUlong = MethodName;
if (InputParam1 == NULL)
{
size = sizeof(ACPI_EVAL_INPUT_BUFFER);
pInputBuffer->Signature = ACPI_EVAL_INPUT_BUFFER_SIGNATURE;
}
else
{
size = sizeof(ACPI_EVAL_INPUT_BUFFER_COMPLEX);
pInputBuffer->Signature = ACPI_EVAL_INPUT_BUFFER_COMPLEX_SIGNATURE;
pInputBuffer->Size = sizeof(ACPI_METHOD_ARGUMENT);
pInputBuffer->ArgumentCount = 1;
pInputBuffer->Argument[0].Type = ACPI_METHOD_ARGUMENT_INTEGER;
pInputBuffer->Argument[0].DataLength = sizeof(ULONG);
pInputBuffer->Argument[0].Argument = *InputParam1;
}
if (InputParam2)
{
size = sizeof(ACPI_EVAL_INPUT_BUFFER_COMPLEX) +
sizeof(ACPI_METHOD_ARGUMENT);
pInputBuffer->Size = 2 * sizeof(ACPI_METHOD_ARGUMENT);
pInputBuffer->ArgumentCount = 2;
pInputBuffer->Argument[1].Type = ACPI_METHOD_ARGUMENT_INTEGER;
pInputBuffer->Argument[1].DataLength = sizeof(ULONG);
pInputBuffer->Argument[1].Argument = *InputParam2;
}
//
// Initialize an event to wait on
//
KeInitializeEvent(&event, SynchronizationEvent, FALSE);
//
// Build the request
//
irp = IoBuildDeviceIoControlRequest(IOCTL_ACPI_EVAL_METHOD,
DeviceObject,
pInputBuffer,
size,
pOutputBuffer,
OutputBufferSize,
FALSE,
&event,
&ioBlock);
if (!irp)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Pass request to DeviceObject, always wait for completion routine
//
status = IoCallDriver(DeviceObject, irp);
if (status == STATUS_PENDING)
{
//
// Wait for the irp to be completed, then grab the real status code
//
KeWaitForSingleObject(&event,
Executive,
KernelMode,
FALSE,
NULL);
status = ioBlock.Status;
}
//
// Sanity check the data
//
if (NT_SUCCESS(status) && OutputBufferSize != 0)
{
if (((pOutputBuffer)->Signature != ACPI_EVAL_OUTPUT_BUFFER_SIGNATURE) ||
((pOutputBuffer)->Count == 0))
{
status = STATUS_ACPI_INVALID_DATA;
}
}
return status;
}
NTSTATUS
pVideoMiniDeviceIoControl(
IN PDEVICE_OBJECT DeviceObject,
IN ULONG dwIoControlCode,
IN PVOID lpInBuffer,
IN ULONG nInBufferSize,
OUT PVOID lpOutBuffer,
IN ULONG nOutBufferSize
)
{
PFDO_EXTENSION combinedExtension;
PFDO_EXTENSION fdoExtension;
VIDEO_REQUEST_PACKET vrp;
STATUS_BLOCK statusBlock;
combinedExtension = DeviceObject->DeviceExtension;
fdoExtension = combinedExtension->pFdoExtension;
statusBlock.Status = ERROR_INVALID_FUNCTION;
vrp.IoControlCode = dwIoControlCode;
vrp.StatusBlock = &statusBlock;
vrp.InputBuffer = lpInBuffer;
vrp.InputBufferLength = nInBufferSize;
vrp.OutputBuffer = lpOutBuffer;
vrp.OutputBufferLength = nOutBufferSize;
//
// Send the request to the miniport directly.
//
fdoExtension->HwStartIO(combinedExtension->HwDeviceExtension, &vrp);
pVideoPortMapToNtStatus(&statusBlock);
return (statusBlock.Status);
}
NTSTATUS
VpSetLCDPowerUsage(
IN PDEVICE_OBJECT DeviceObject,
IN BOOLEAN FullPower
)
/*++
Routine Description:
It changes the brightness level, based on the value of FullPower.
Arguments:
DeviceObject: the ACPI device object attached to our LCD device.
FullPower: if TRUE, it sets the brightness level to FullPower level
if FALSE, it sets the brightness level to Battery level
Returns:
NO_ERROR if it succeeds
Various error codes if it fails
--*/
{
PACPI_EVAL_OUTPUT_BUFFER Buffer = NULL;
PACPI_METHOD_ARGUMENT Argument = NULL;
ULONG Granularity = 80;
ULONG BufferMaxSize = 4096;
NTSTATUS Status = STATUS_UNSUCCESSFUL;
ULONG Level = 100;
PAGED_CODE();
ASSERT (DeviceObject != NULL);
//
// Get the list of brightness levels supported
//
do {
Buffer = (PACPI_EVAL_OUTPUT_BUFFER)ExAllocatePoolWithTag(
PagedPool,
Granularity,
VP_TAG);
if (Buffer == NULL) {
pVideoDebugPrint((Warn,
"VIDEOPRT: VpSetLCDPowerUsage: Memory allocation failed."));
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
RtlZeroMemory(Buffer, Granularity);
Status = pVideoPortACPIIoctl(
DeviceObject,
(ULONG) ('LCB_'),
NULL,
NULL,
Granularity,
Buffer);
if (Status == STATUS_BUFFER_OVERFLOW) {
ExFreePool(Buffer);
Buffer = NULL;
Granularity <<= 1;
if (Granularity > BufferMaxSize) {
pVideoDebugPrint((Warn,
"VIDEOPRT: _BCL failed. Expected buffer is too big."));
Status = STATUS_ACPI_INVALID_DATA;
break;
}
} else if (!NT_SUCCESS(Status)) {
pVideoDebugPrint((Warn,
"VIDEOPRT: _BCL failed. Status = 0x%x\n", Status));
} else {
pVideoDebugPrint((Trace, "VIDEOPRT: _BCL succeeded.\n"));
}
} while (Status == STATUS_BUFFER_OVERFLOW);
if ((Buffer == NULL) || (!NT_SUCCESS(Status)))
goto Fallout;
//
// Now try to set the state.
//
if (Buffer->Count < 2) {
pVideoDebugPrint((Warn,
"VIDEOPRT: _BCL returned an invalid number of arguments."));
Status = STATUS_ACPI_INVALID_DATA;
goto Fallout;
}
Argument = Buffer->Argument;
if (Argument->Type != ACPI_METHOD_ARGUMENT_INTEGER) {
pVideoDebugPrint((Warn,
"VIDEOPRT: _BCL returned an invalid argument."));
Status = STATUS_ACPI_INVALID_DATA;
goto Fallout;
}
Level = Argument->Argument;
if (!FullPower) {
Argument = ACPI_METHOD_NEXT_ARGUMENT(Argument);
if (Argument->Type != ACPI_METHOD_ARGUMENT_INTEGER) {
pVideoDebugPrint((Warn,
"VIDEOPRT: _BCL returned an invalid argument."));
Status = STATUS_ACPI_INVALID_DATA;
goto Fallout;
}
//
// Full power level should be greater than the battery level
//
ASSERT (Level >= Argument->Argument);
Level = Argument->Argument;
}
Status = pVideoPortACPIIoctl(
DeviceObject,
(ULONG) ('MCB_'),
&Level,
NULL,
0,
(PACPI_EVAL_OUTPUT_BUFFER)NULL);
if (!NT_SUCCESS(Status)) {
pVideoDebugPrint((Warn,
"VIDEOPRT: _BCM failed. Status = 0x%x\n", Status));
} else {
pVideoDebugPrint((Trace, "VIDEOPRT: _BCM succeeded.\n"));
}
Fallout:
if (Buffer != NULL) {
ExFreePool(Buffer);
}
return Status;
}
VOID
VpPowerStateCallback(
IN PVOID CallbackContext,
IN PVOID Argument1,
IN PVOID Argument2
)
/*++
Routine Description:
This is the callback routine that is called when the power state changes.
Arguments:
CallbackContext: NULL
Argument1: event code
Argument2: if Argument1 is PO_CB_AC_STATUS, Argument2 contains TRUE if
the current power source is AC and FALSE otherwise.
Note:
This function can be called at DISPATCH_LEVEL
--*/
{
PPOWER_STATE_WORK_ITEM PowerStateWorkItem = NULL;
ASSERT (CallbackContext == NULL);
switch ((ULONG_PTR)Argument1) {
case PO_CB_LID_SWITCH_STATE:
case PO_CB_AC_STATUS:
PowerStateWorkItem =
(PPOWER_STATE_WORK_ITEM)ExAllocatePoolWithTag(
NonPagedPool,
sizeof(POWER_STATE_WORK_ITEM),
VP_TAG);
if (PowerStateWorkItem != NULL) {
PowerStateWorkItem->Argument1 = Argument1;
PowerStateWorkItem->Argument2 = Argument2;
ExInitializeWorkItem(
&PowerStateWorkItem->WorkItem,
VpDelayedPowerStateCallback,
PowerStateWorkItem);
ExQueueWorkItem(
&PowerStateWorkItem->WorkItem,
DelayedWorkQueue);
} else {
pVideoDebugPrint((Warn,
"VIDEOPRT: VpPowerStateCallback: Memory allocation failed."));
}
break;
default:
//
// Ignore all other cases
//
break;
}
}
VOID
VpDelayedPowerStateCallback(
IN PVOID Context
)
/*++
Routine Description:
VpPowerStateCallback queues this work item in order to handle
PowerState changes at PASSIVE_LEVEL.
Arguments:
Context: pointer to POWER_STATE_WORK_ITEM
--*/
{
PPOWER_STATE_WORK_ITEM PowerStateWorkItem =
(PPOWER_STATE_WORK_ITEM)Context;
PDEVICE_OBJECT AttachedDevice = NULL;
NTSTATUS status;
POWER_STATE powerState;
PCHILD_PDO_EXTENSION pdoExtension;
BOOLEAN PowerOverride;
PAGED_CODE();
ASSERT (PowerStateWorkItem != NULL);
KeWaitForSingleObject(&LCDPanelMutex,
Executive,
KernelMode,
FALSE,
(PTIME)NULL);
if (LCDPanelDevice == NULL) {
goto Fallout;
}
switch ((ULONG_PTR)PowerStateWorkItem->Argument1) {
case PO_CB_AC_STATUS:
AttachedDevice = IoGetAttachedDeviceReference(LCDPanelDevice);
VpSetLCDPowerUsage(
AttachedDevice,
(PowerStateWorkItem->Argument2 != 0));
ObDereferenceObject(AttachedDevice);
break;
case PO_CB_LID_SWITCH_STATE:
pdoExtension = LCDPanelDevice->DeviceExtension;
if ((ULONG_PTR)PowerStateWorkItem->Argument2 == 0) {
//
// The lid is closed. Put the LCD Panel into D3 and override
// any future power requests to the panel.
//
PowerOverride = TRUE;
powerState.DeviceState = PowerDeviceD3;
pVideoDebugPrint((Trace, "VIDEOPRT: LCD Panel Closed.\n"));
} else if ((ULONG_PTR)PowerStateWorkItem->Argument2 == 1) {
pdoExtension->PowerOverride = PowerOverride = FALSE;
powerState.DeviceState = PowerDeviceD0;
pVideoDebugPrint((Trace, "VIDEOPRT: LCD Panel Open.\n"));
} else {
pVideoDebugPrint((Error, "VIDEOPRT: Unknown LCD lid close event recieved.\n"));
ASSERT(FALSE);
goto Fallout;
}
if (pdoExtension->pFdoExtension->DevicePowerState == PowerDeviceD0)
{
status = PoRequestPowerIrp (LCDPanelDevice,
IRP_MN_SET_POWER,
powerState,
pVideoPortPowerIrpComplete,
(PVOID)NULL,
NULL);
if (status != STATUS_PENDING) {
pVideoDebugPrint((Error, "VIDEOPRT: Could not send power IRP to toggle panel\n"));
}
}
pdoExtension->PowerOverride = PowerOverride;
break;
default:
pVideoDebugPrint((Warn,
"VIDEOPRT: Unexpected PowerState event recieved.\n"));
ASSERT(FALSE);
break;
}
Fallout:
KeReleaseMutex(&LCDPanelMutex, FALSE);
ExFreePool(Context);
}
VOID
VpRegisterPowerStateCallback(
VOID
)
/*++
Routine Description:
This routine registers the PowerState callback routine.
--*/
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING CallbackName;
PCALLBACK_OBJECT CallbackObject;
NTSTATUS Status;
PAGED_CODE();
RtlInitUnicodeString(&CallbackName, L"\\Callback\\PowerState");
InitializeObjectAttributes(
&ObjectAttributes,
&CallbackName,
OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
NULL,
NULL
);
Status = ExCreateCallback(
&CallbackObject,
&ObjectAttributes,
FALSE,
TRUE
);
if (NT_SUCCESS(Status)) {
PowerStateCallbackHandle = ExRegisterCallback(
CallbackObject,
VpPowerStateCallback,
NULL
);
if (PowerStateCallbackHandle == NULL) {
pVideoDebugPrint((Warn,
"VIDEOPRT: Could not register VpPowerStateCallback.\n"));
} else {
pVideoDebugPrint((Trace,
"VIDEOPRT: VpPowerStateCallback registered. \n"));
}
} else {
pVideoDebugPrint((Warn,
"VIDEOPRT: Could not get the PowerState callback object.\n"));
}
}
VOID
VpRegisterLCDCallbacks(
VOID
)
/*++
Routine Description:
This routine registers a callback with the system so that we can
be notified of power state changes.
--*/
{
PAGED_CODE();
//
// Register power state callback. This works for the lid as well.
//
if (PowerStateCallbackHandle == NULL) {
VpRegisterPowerStateCallback();
}
}
VOID
VpUnregisterLCDCallbacks(
VOID
)
/*++
Routine Description:
This routine unregisters the callbacks previously registered by
VpRegisterLCDCallbacks
Arguments:
None.
Note:
The global PowerStateCallbackHandle acts as an implicit parameter.
--*/
{
PAGED_CODE();
//
// Unregister power state callback
//
if (PowerStateCallbackHandle != NULL) {
ExUnregisterCallback(PowerStateCallbackHandle);
PowerStateCallbackHandle = NULL;
}
}