able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/busdrv/acpi/driver/nt/acpidock.c

2067 lines
50 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1998 Microsoft Corporation
Module Name:
acpidock.c
Abstract:
This module handles docking issues for ACPI.
For each dock, we create a node off the root of ACPI called a "profile
provider". This node represents that individual dock. We do this so
that the OS can determine the current or upcoming hardware profile
without having to start that portion of the tree which leads down to
the dock. Also, as multiple simulataneous docks are supported via ACPI,
we make them all children of the root so that the OS can pick up the
hardware profile in just one pass.
Author:
Adrian J. Oney (AdriaO)
Environment:
Kernel mode only.
Revision History:
20-Jan-98 Initial Revision
--*/
#include "pch.h"
#include "amlreg.h"
#include <stdio.h>
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE,ACPIDockIrpStartDevice)
#pragma alloc_text(PAGE,ACPIDockIrpQueryCapabilities)
#pragma alloc_text(PAGE,ACPIDockIrpQueryDeviceRelations)
#pragma alloc_text(PAGE,ACPIDockIrpEject)
#pragma alloc_text(PAGE,ACPIDockIrpQueryID)
#pragma alloc_text(PAGE,ACPIDockIrpSetLock)
#pragma alloc_text(PAGE,ACPIDockIrpQueryEjectRelations)
#pragma alloc_text(PAGE,ACPIDockIrpQueryInterface)
#pragma alloc_text(PAGE,ACPIDockIrpQueryPnpDeviceState)
#pragma alloc_text(PAGE,ACPIDockIntfReference)
#pragma alloc_text(PAGE,ACPIDockIntfDereference)
#pragma alloc_text(PAGE,ACPIDockIntfSetMode)
#pragma alloc_text(PAGE,ACPIDockIntfUpdateDeparture)
#endif
PDEVICE_EXTENSION
ACPIDockFindCorrespondingDock(
IN PDEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
This routine takes a pointer to an ACPI object an returns the dock extension
that matches it.
Argument Description:
DeviceExtension - The device for which we want the dock
Return Value:
NULL or the matching extension for the profile provider
--*/
{
PDEVICE_EXTENSION rootChildExtension = NULL ;
EXTENSIONLIST_ENUMDATA eled ;
ACPIExtListSetupEnum(
&eled,
&(RootDeviceExtension->ChildDeviceList),
&AcpiDeviceTreeLock,
SiblingDeviceList,
WALKSCHEME_HOLD_SPINLOCK
) ;
for(rootChildExtension = ACPIExtListStartEnum(&eled);
ACPIExtListTestElement(&eled, TRUE) ;
rootChildExtension = ACPIExtListEnumNext(&eled)) {
if (!rootChildExtension) {
ACPIExtListExitEnumEarly(&eled);
break;
}
if (!(rootChildExtension->Flags & DEV_PROP_DOCK)) {
continue;
}
if (rootChildExtension->Dock.CorrospondingAcpiDevice ==
DeviceExtension) {
ACPIExtListExitEnumEarly(&eled) ;
break;
}
}
//
// Done
//
return rootChildExtension;
}
NTSTATUS
ACPIDockGetDockObject(
IN PNSOBJ AcpiObject,
OUT PNSOBJ *dckObject
)
/*++
Routine Description:
This routine gets the _DCK method object if the device has one
Arguments:
The ACPI Object to test.
Return Value:
NTSTATUS (failure if _DCK method does not exist)
--*/
{
return AMLIGetNameSpaceObject(
"_DCK",
AcpiObject,
dckObject,
NSF_LOCAL_SCOPE
);
}
NTSTATUS
ACPIDockIrpEject(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
Arguments:
DeviceObject - The device to get the capabilities for
Irp - The request to the device to tell it to stop
Return Value:
NTSTATUS
--*/
{
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation( Irp );
UCHAR minorFunction = irpStack->MinorFunction;
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);
PDEVICE_EXTENSION dockDeviceExtension;
PNSOBJ ej0Object;
NTSTATUS status;
ULONG i, ignoredPerSpec ;
PAGED_CODE();
//
// The dock may have failed _DCK on a start, in which case we have kept
// it around for the explicit purpose of ejecting it. Now we make the dock
// go away.
//
ACPIInternalUpdateFlags(
&(deviceExtension->Flags),
DEV_CAP_UNATTACHED_DOCK,
TRUE
);
//
// lets get the corrosponding dock node for this device
//
dockDeviceExtension = deviceExtension->Dock.CorrospondingAcpiDevice ;
if (!dockDeviceExtension) {
//
// Invalid name space object <bad>
//
ACPIDevPrint( (
ACPI_PRINT_FAILURE,
deviceExtension,
"(0x%08lx): ACPIDockIrpEject: no corresponding extension!!\n",
Irp
) );
ASSERT(0);
//
// Mark the irp as very bad...
//
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL ;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return STATUS_UNSUCCESSFUL;
}
if (deviceExtension->Dock.ProfileDepartureStyle == PDS_UPDATE_ON_EJECT) {
//
// On the Compaq Armada 7800, we switch UARTs during an undock, thus we
// lose the debugger com port programming.
//
KdDisableDebugger();
if (deviceExtension->Dock.IsolationState != IS_ISOLATED) {
status = ACPIGetIntegerEvalIntegerSync(
dockDeviceExtension,
PACKED_DCK,
0,
&ignoredPerSpec
);
deviceExtension->Dock.IsolationState = IS_ISOLATED;
}
if (!NT_SUCCESS(status)) {
KdEnableDebugger();
Irp->IoStatus.Status = status ;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return status ;
}
}
ej0Object = ACPIAmliGetNamedChild(
dockDeviceExtension->AcpiObject,
PACKED_EJ0
);
if (ej0Object != NULL) {
status = ACPIGetNothingEvalIntegerSync(
dockDeviceExtension,
PACKED_EJ0,
1
);
} else {
status = STATUS_OBJECT_NAME_NOT_FOUND;
}
if (deviceExtension->Dock.ProfileDepartureStyle == PDS_UPDATE_ON_EJECT) {
KdEnableDebugger() ;
}
//
// The dock may have failed _DCK on a start, in which case we have kept
// it around for the explicit purpose of ejecting it. Now we make the dock
// go away.
//
ACPIInternalUpdateFlags(
&(deviceExtension->Flags),
DEV_CAP_UNATTACHED_DOCK,
TRUE
);
if (NT_SUCCESS(status)) {
//
// Get the currrent device status
//
status = ACPIGetDevicePresenceSync(
deviceExtension,
(PVOID *) &i,
NULL
);
if (NT_SUCCESS(status) &&
!(deviceExtension->Flags & DEV_TYPE_NOT_PRESENT)) {
ACPIDevPrint( (
ACPI_PRINT_FAILURE,
deviceExtension,
"(0x%08lx): ACPIDockIrpEjectDevice: "
"dock is still listed as present after _DCK/_EJx!\n",
Irp
) );
//
// The device did not go away. Let us fail this
//
status = STATUS_UNSUCCESSFUL ;
}
}
Irp->IoStatus.Status = status;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return status ;
}
NTSTATUS
ACPIDockIrpQueryCapabilities(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This handles a request to get the capabilities of a device.
Arguments:
DeviceObject - The device to get the capabilities for
Irp - The request to the device to tell it to stop
Return Value:
NTSTATUS
--*/
{
NTSTATUS status ;
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);
PDEVICE_EXTENSION dockDeviceExtension;
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation( Irp );
UCHAR minorFunction = irpStack->MinorFunction;
PDEVICE_CAPABILITIES capabilities;
PNSOBJ acpiObject ;
PAGED_CODE();
//
// Grab a pointer to the capabilities
//
capabilities = irpStack->Parameters.DeviceCapabilities.Capabilities;
dockDeviceExtension = deviceExtension->Dock.CorrospondingAcpiDevice ;
if (!dockDeviceExtension) {
ACPIDevPrint( (
ACPI_PRINT_FAILURE,
deviceExtension,
"(0x%08lx): ACPIDockIrpQueryCapabilities: "
"no corresponding extension!!\n",
Irp
) );
ASSERT(0) ;
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL ;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return STATUS_UNSUCCESSFUL;
}
acpiObject = dockDeviceExtension->AcpiObject ;
//
// Set the current flags for the capabilities
//
capabilities->SilentInstall = TRUE;
capabilities->RawDeviceOK = TRUE;
capabilities->DockDevice = TRUE;
capabilities->Removable = TRUE;
capabilities->UniqueID = TRUE;
if (ACPIAmliGetNamedChild( acpiObject, PACKED_EJ0)) {
capabilities->EjectSupported = TRUE;
}
if (ACPIAmliGetNamedChild( acpiObject, PACKED_EJ1) ||
ACPIAmliGetNamedChild( acpiObject, PACKED_EJ2) ||
ACPIAmliGetNamedChild( acpiObject, PACKED_EJ3) ||
ACPIAmliGetNamedChild( acpiObject, PACKED_EJ4)) {
capabilities->WarmEjectSupported = TRUE;
}
//
// An object of this name signifies the node is lockable
//
#if !defined(ACPI_INTERNAL_LOCKING)
if (ACPIAmliGetNamedChild( acpiObject, PACKED_LCK) != NULL) {
capabilities->LockSupported = TRUE;
}
#endif
//
// Internally record the power capabilities
//
status = ACPISystemPowerQueryDeviceCapabilities(
deviceExtension,
capabilities
);
//
// Round down S1-S3 to D3. This will ensure we reexamine the _STA after
// resume from sleep (note that we won't actually be playing with the docks
// power methods, so this is safe)
//
capabilities->DeviceState[PowerSystemSleeping1] = PowerDeviceD3;
capabilities->DeviceState[PowerSystemSleeping2] = PowerDeviceD3;
capabilities->DeviceState[PowerSystemSleeping3] = PowerDeviceD3;
//
// We can do this slimy-like because we don't have any Wake bits or
// anything else fancy.
//
IoCopyDeviceCapabilitiesMapping(
capabilities,
deviceExtension->PowerInfo.DevicePowerMatrix
);
//
// Now update our power matrix.
//
if (!NT_SUCCESS(status)) {
ACPIDevPrint( (
ACPI_PRINT_CRITICAL,
deviceExtension,
" - Could query device capabilities - %08lx",
status
) );
}
ACPIDevPrint( (
ACPI_PRINT_IRP,
deviceExtension,
"(0x%08lx): %s = 0x%08lx\n",
Irp,
ACPIDebugGetIrpText(IRP_MJ_PNP, minorFunction),
status
) );
Irp->IoStatus.Status = status;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return status;
}
NTSTATUS
ACPIDockIrpQueryDeviceRelations(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This handles a request to query device relations. Since profile providers
never have children, we only need to fix up the eject relations
appropriately
Arguments:
DeviceObject - The device to get the capabilities for
Irp - The request to the device to tell it to stop
Return Value:
NTSTATUS
--*/
{
NTSTATUS status = STATUS_NOT_SUPPORTED;
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);
PDEVICE_RELATIONS deviceRelations = (PDEVICE_RELATIONS) Irp->IoStatus.Information;
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation( Irp );
UCHAR minorFunction = irpStack->MinorFunction;
PAGED_CODE();
switch(irpStack->Parameters.QueryDeviceRelations.Type) {
case BusRelations:
break ;
case TargetDeviceRelation:
status = ACPIBusIrpQueryTargetRelation(
DeviceObject,
Irp,
&deviceRelations
);
break ;
case EjectionRelations:
status = ACPIDockIrpQueryEjectRelations(
DeviceObject,
Irp,
&deviceRelations
);
break ;
default:
ACPIDevPrint( (
ACPI_PRINT_IRP,
deviceExtension,
"(0x%08lx): %s - Unhandled Type %d\n",
Irp,
ACPIDebugGetIrpText(IRP_MJ_PNP, minorFunction),
irpStack->Parameters.QueryDeviceRelations.Type
) );
break ;
}
//
// If we succeeds, then we can always write to the irp
//
if (NT_SUCCESS(status)) {
Irp->IoStatus.Status = status;
Irp->IoStatus.Information = (ULONG_PTR) deviceRelations;
} else if ((status != STATUS_NOT_SUPPORTED) && (deviceRelations == NULL)) {
//
// If we haven't succeed the irp, then we can also fail it, but only
// if nothing else has been added.
//
Irp->IoStatus.Status = status;
Irp->IoStatus.Information = (ULONG_PTR) NULL;
} else {
//
// Grab our status from what is already present
//
status = Irp->IoStatus.Status;
}
//
// Done with the irp
//
IoCompleteRequest( Irp, IO_NO_INCREMENT );
//
// Done
//
ACPIDevPrint( (
ACPI_PRINT_IRP,
deviceExtension,
"(0x%08lx): %s = 0x%08lx\n",
Irp,
ACPIDebugGetIrpText(IRP_MJ_PNP, minorFunction),
status
) );
return status;
}
NTSTATUS
ACPIDockIrpQueryEjectRelations(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN OUT PDEVICE_RELATIONS *PdeviceRelations
)
{
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);
PDEVICE_EXTENSION dockDeviceExtension ;
PNSOBJ acpiObject = NULL;
NTSTATUS status ;
PAGED_CODE();
//
// lets get the corrosponding dock node for this device
//
dockDeviceExtension = deviceExtension->Dock.CorrospondingAcpiDevice ;
if (!dockDeviceExtension) {
//
// Invalid name space object <bad>
//
ACPIDevPrint( (
ACPI_PRINT_FAILURE,
deviceExtension,
"(0x%08lx): ACPIDockIrpQueryEjectRelations: "
"no corresponding extension!!\n",
Irp
) );
ASSERT(0) ;
return STATUS_UNSUCCESSFUL;
}
//
// lets look at the ACPIObject that we have so can see if it is valid...
//
acpiObject = dockDeviceExtension->AcpiObject;
if (acpiObject == NULL) {
//
// Invalid name space object <bad>
//
ACPIDevPrint( (
ACPI_PRINT_CRITICAL,
deviceExtension,
"(0x%08lx): ACPIDockIrpQueryEjectRelations: "
"invalid ACPIObject (0x%08lx)\n",
acpiObject
) );
return STATUS_INVALID_PARAMETER;
}
status = ACPIDetectEjectDevices(
dockDeviceExtension,
PdeviceRelations,
dockDeviceExtension
);
//
// If something went wrong...
//
if (!NT_SUCCESS(status)) {
//
// That's not nice..
//
ACPIDevPrint( (
ACPI_PRINT_CRITICAL,
deviceExtension,
"(0x%08lx): ACPIDockIrpQueryEjectRelations: enum 0x%08lx\n",
Irp,
status
) );
}
return status ;
}
NTSTATUS
ACPIDockIrpQueryID(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine is the dispatch point for the IRP_MN_QUERY_ID PNP
minor function
Note: This is what the returned strings from this function should look
like.
DeviceID = ACPI\DockDevice
InstanceID = ACPI object node ( CDCK, etc )
HardwareIDs = ACPI\DockDevice&_SB.DOCK, ACPI\DockDevice
Arguments:
DeviceObject - The object that we care about
Irp - The request in question
Return Value:
NTSTATUS
--*/
{
BUS_QUERY_ID_TYPE type;
NTSTATUS status;
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);
PDEVICE_EXTENSION dockDeviceExtension;
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation( Irp );
PNSOBJ acpiObject = deviceExtension->AcpiObject;
PUCHAR buffer;
UCHAR minorFunction = irpStack->MinorFunction;
UNICODE_STRING unicodeIdString;
PWCHAR serialID;
ULONG firstHardwareIDLength;
PAGED_CODE();
//
// Initilize the Unicode Structure
//
RtlZeroMemory( &unicodeIdString, sizeof(UNICODE_STRING) );
//
// What we do is based on the IdType of the Request...
//
type = irpStack->Parameters.QueryId.IdType;
switch (type) {
case BusQueryDeviceID:
//
// We pre-calculate this since it is so useful for debugging
//
status = ACPIInitUnicodeString(
&unicodeIdString,
deviceExtension->DeviceID
);
break;
case BusQueryDeviceSerialNumber:
//
// lets get the corrosponding dock node for this device
//
dockDeviceExtension = deviceExtension->Dock.CorrospondingAcpiDevice;
if (!dockDeviceExtension) {
//
// Invalid name space object <bad>
//
ACPIDevPrint( (
ACPI_PRINT_FAILURE,
deviceExtension,
"(0x%08lx): ACPIDockIrpQueryID: no corresponding extension!!\n",
Irp
) );
ASSERT(0);
//
// Mark the irp as very bad...
//
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return STATUS_UNSUCCESSFUL;
}
status = ACPIGetSerialIDWide(
dockDeviceExtension,
&serialID,
NULL
);
if (!NT_SUCCESS(status)) {
break;
}
//
// Return the Serial Number for the DockDevice
//
unicodeIdString.Buffer = serialID;
break;
case BusQueryInstanceID:
//
// We pre-calculate this since it is so useful for debugging
//
status = ACPIInitUnicodeString(
&unicodeIdString,
deviceExtension->InstanceID
);
break;
case BusQueryCompatibleIDs:
status = STATUS_NOT_SUPPORTED;
break;
case BusQueryHardwareIDs:
//
// Now set our identifier. In theory, the OS could use this
// string in any scenario, although in reality it will key off
// of the dock ID.
//
// Construct the MultiSz hardware ID list:
// ACPI\DockDevice&_SB.PCI0.DOCK
// ACPI\DockDevice
//
status = ACPIInitMultiString(
&unicodeIdString,
"ACPI\\DockDevice",
deviceExtension->InstanceID,
"ACPI\\DockDevice",
NULL
);
if (NT_SUCCESS(status)) {
//
// Replace first '\0' with '&'
//
firstHardwareIDLength = wcslen(unicodeIdString.Buffer);
unicodeIdString.Buffer[firstHardwareIDLength] = L'&';
}
break;
default:
ACPIDevPrint( (
ACPI_PRINT_IRP,
deviceExtension,
"(0x%08lx): %s - Unhandled Id %d\n",
Irp,
ACPIDebugGetIrpText(IRP_MJ_PNP, minorFunction),
type
) );
status = STATUS_NOT_SUPPORTED;
break;
} // switch
//
// Did we pass or did we fail?
//
if (NT_SUCCESS(status)) {
Irp->IoStatus.Information = (ULONG_PTR) unicodeIdString.Buffer;
} else {
Irp->IoStatus.Information = (ULONG_PTR) NULL;
}
Irp->IoStatus.Status = status;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
ACPIDevPrint( (
ACPI_PRINT_IRP,
deviceExtension,
"(0x%08lx): %s(%d) = 0x%08lx\n",
Irp,
ACPIDebugGetIrpText(IRP_MJ_PNP, minorFunction),
type,
status
) );
return status;
}
NTSTATUS
ACPIDockIrpQueryInterface(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine is the dispatch point for the IRP_MN_QUERY_INTERFACE minor
function. The only reason we respond to this is so we can handle the
dock interface which is used to solve the removal ordering problem we won't
be fixing 5.0 (sigh).
Arguments:
DeviceObject - The object that we care about
Irp - The request in question
Return Value:
NTSTATUS
--*/
{
NTSTATUS status;
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation( Irp );
UCHAR minorFunction = irpStack->MinorFunction;
LPGUID interfaceType;
PAGED_CODE();
status = Irp->IoStatus.Status;
interfaceType = (LPGUID) irpStack->Parameters.QueryInterface.InterfaceType;
if (CompareGuid(interfaceType, (PVOID) &GUID_DOCK_INTERFACE)) {
DOCK_INTERFACE dockInterface;
USHORT count;
//
// Only copy up to current size of the ACPI_INTERFACE structure
//
if (irpStack->Parameters.QueryInterface.Size > sizeof(DOCK_INTERFACE)) {
count = sizeof(DOCK_INTERFACE);
} else {
count = irpStack->Parameters.QueryInterface.Size;
}
//
// Build up the interface structure.
//
dockInterface.Size = count;
dockInterface.Version = DOCK_INTRF_STANDARD_VER;
dockInterface.Context = DeviceObject;
dockInterface.InterfaceReference = ACPIDockIntfReference;
dockInterface.InterfaceDereference = ACPIDockIntfDereference;
dockInterface.ProfileDepartureSetMode = ACPIDockIntfSetMode;
dockInterface.ProfileDepartureUpdate = ACPIDockIntfUpdateDeparture;
//
// Give it a reference
//
dockInterface.InterfaceReference(dockInterface.Context);
//
// Hand back the interface
//
RtlCopyMemory(
(PDOCK_INTERFACE) irpStack->Parameters.QueryInterface.Interface,
&dockInterface,
count
);
//
// We're done with this irp
//
Irp->IoStatus.Status = status = STATUS_SUCCESS;
}
IoCompleteRequest( Irp, IO_NO_INCREMENT );
ACPIDevPrint( (
ACPI_PRINT_IRP,
deviceExtension,
"(0x%08lx): %s = 0x%08lx\n",
Irp,
ACPIDebugGetIrpText(IRP_MJ_PNP, minorFunction),
status
) );
return status;
}
NTSTATUS
ACPIDockIrpQueryPnpDeviceState(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine is the dispatch point for the IRP_MN_QUERY_PNP_DEVICE_STATE
minor function. The only reason we respond to this is so we can set the
PNP_DEVICE_DONT_DISPLAY_IN_UI flag (we are a raw PDO that does not need
to be visible)
Arguments:
DeviceObject - The object that we care about
Irp - The request in question
Return Value:
NTSTATUS
--*/
{
NTSTATUS status = STATUS_SUCCESS;
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation( Irp );
UCHAR minorFunction = irpStack->MinorFunction;
PAGED_CODE();
Irp->IoStatus.Information |= PNP_DEVICE_DONT_DISPLAY_IN_UI ;
Irp->IoStatus.Status = status;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
ACPIDevPrint( (
ACPI_PRINT_IRP,
deviceExtension,
"(0x%08lx): %s = 0x%08lx\n",
Irp,
ACPIDebugGetIrpText(IRP_MJ_PNP, minorFunction),
status
) );
return status;
}
NTSTATUS
ACPIDockIrpQueryPower(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routines tells the system what PNP state the device is in
Arguments:
DeviceObject - The device whose state we want to know
Irp - The request
Return Value:
NTSTATUS
--*/
{
NTSTATUS status;
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);
PDEVICE_EXTENSION dockDeviceExtension ;
PIO_STACK_LOCATION irpSp;
PNSOBJ acpiObject, ejectObject ;
SYSTEM_POWER_STATE systemState;
ULONG packedEJx ;
dockDeviceExtension = deviceExtension->Dock.CorrospondingAcpiDevice ;
if (!dockDeviceExtension) {
ACPIDevPrint( (
ACPI_PRINT_FAILURE,
deviceExtension,
"(0x%08lx): ACPIDockIrpQueryPower - "
"no corresponding extension!!\n",
Irp
) );
ASSERT(0) ;
return ACPIDispatchPowerIrpSuccess( DeviceObject, Irp );
}
//
// Get the Current stack location to determine if we are a system
// irp or a device irp. We ignore device irps here.
//
irpSp = IoGetCurrentIrpStackLocation(Irp);
if (irpSp->Parameters.Power.Type != SystemPowerState) {
//
// We don't handle this irp
//
return ACPIDispatchPowerIrpSuccess( DeviceObject, Irp );
}
if (irpSp->Parameters.Power.ShutdownType != PowerActionWarmEject) {
//
// No eject work - complete the IRP.
//
return ACPIDispatchPowerIrpSuccess( DeviceObject, Irp );
}
//
// Restrict power states to those supported.
//
acpiObject = dockDeviceExtension->AcpiObject;
//
// What system state are we looking at?
//
systemState = irpSp->Parameters.Power.State.SystemState;
switch (irpSp->Parameters.Power.State.SystemState) {
case PowerSystemSleeping1:
packedEJx = PACKED_EJ1;
break;
case PowerSystemSleeping2:
packedEJx = PACKED_EJ2;
break;
case PowerSystemSleeping3:
packedEJx = PACKED_EJ3;
break;
case PowerSystemHibernate:
packedEJx = PACKED_EJ4;
break;
case PowerSystemWorking:
case PowerSystemShutdown:
default:
packedEJx = 0;
break;
}
if (packedEJx) {
ejectObject = ACPIAmliGetNamedChild( acpiObject, packedEJx);
if (ejectObject == NULL) {
//
// Fail the request, as we cannot eject in this case.
//
PoStartNextPowerIrp( Irp );
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return STATUS_UNSUCCESSFUL;
}
}
return ACPIDispatchPowerIrpSuccess( DeviceObject, Irp );
}
NTSTATUS
ACPIDockIrpRemoveDevice(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine is called when we need to remove the device. Note that we only
delete ourselves if we have been undocked (ie, our hardware is gone)
Arguments:
DeviceObject - The dock device to "remove"
Irp - The request to the device to tell it to go away
Return Value:
NTSTATUS
--*/
{
LONG oldReferenceCount;
KIRQL oldIrql;
NTSTATUS status = STATUS_SUCCESS;
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation( Irp );
UCHAR minorFunction = irpStack->MinorFunction;
ULONG i, ignoredPerSpec;
if (!(deviceExtension->Flags & DEV_MASK_NOT_PRESENT)) {
//
// If the device is still physically present, so must the PDO be.
// This case is essentially a stop. Mark the request as complete...
//
Irp->IoStatus.Status = status;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return status;
}
if (deviceExtension->DeviceState == Removed) {
Irp->IoStatus.Status = STATUS_NO_SUCH_DEVICE;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return STATUS_NO_SUCH_DEVICE;
}
if (deviceExtension->Dock.ProfileDepartureStyle == PDS_UPDATE_ON_REMOVE) {
PDEVICE_EXTENSION dockDeviceExtension;
//
// lets get the corrosponding dock node for this device
//
dockDeviceExtension = deviceExtension->Dock.CorrospondingAcpiDevice ;
//
// On the Compaq Armada 7800, we switch UARTs during an undock, thus we
// lose the debugger com port programming.
//
if (deviceExtension->Dock.IsolationState != IS_ISOLATED) {
KdDisableDebugger();
status = ACPIGetIntegerEvalIntegerSync(
dockDeviceExtension,
PACKED_DCK,
0,
&ignoredPerSpec
);
KdEnableDebugger();
}
}
//
// The device is gone. Let the isolation state reflect that.
//
deviceExtension->Dock.IsolationState = IS_UNKNOWN;
//
// Set the device state as removed
//
deviceExtension->DeviceState = Removed;
//
// Complete the request
//
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = (ULONG_PTR) NULL;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
//
// Done
//
ACPIDevPrint( (
ACPI_PRINT_IRP,
deviceExtension,
"(0x%08lx): %s = 0x%08lx\n",
Irp,
ACPIDebugGetIrpText(IRP_MJ_PNP, minorFunction),
STATUS_SUCCESS
) );
//
// Update the device extension
//
KeAcquireSpinLock( &AcpiDeviceTreeLock, &oldIrql );
ASSERT(!(deviceExtension->Flags&DEV_TYPE_FILTER)) ;
//
// Step one is to zero out the things that we no longer care about
//
deviceExtension->TargetDeviceObject = NULL;
deviceExtension->PhysicalDeviceObject = NULL;
deviceExtension->DeviceObject = NULL;
//
// Mark the node as being fresh and untouched
//
ACPIInternalUpdateFlags( &(deviceExtension->Flags), DEV_MASK_TYPE, TRUE );
ACPIInternalUpdateFlags( &(deviceExtension->Flags), DEV_TYPE_NOT_FOUND, FALSE );
ACPIInternalUpdateFlags( &(deviceExtension->Flags), DEV_TYPE_REMOVED, FALSE );
//
// The reference count should have value > 0
//
oldReferenceCount = InterlockedDecrement(
&(deviceExtension->ReferenceCount)
);
ASSERT(oldReferenceCount >= 0) ;
if ( oldReferenceCount == 0) {
//
// Delete the extension
//
ACPIInitDeleteDeviceExtension( deviceExtension );
}
//
// Done with the lock
//
KeReleaseSpinLock( &AcpiDeviceTreeLock, oldIrql );
//
// Delete the device
//
IoDeleteDevice( DeviceObject );
//
// Done
//
return STATUS_SUCCESS;
}
NTSTATUS
ACPIDockIrpSetLock(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
Arguments:
DeviceObject - The device to set the lock state for
Irp - The request to the device to tell it to lock
Return Value:
NTSTATUS
--*/
{
NTSTATUS status;
PAGED_CODE();
//
// We aren't a real device, so we don't do locking.
//
status = Irp->IoStatus.Status ;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return status ;
}
NTSTATUS
ACPIDockIrpStartDevice(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This handles a request to start the device
Arguments:
DeviceObject - The device to start
Irp - The request to the device to tell it to start
Return Value:
NTSTATUS
--*/
{
NTSTATUS status = STATUS_SUCCESS;
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);
PDEVICE_EXTENSION dockDeviceExtension;
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation( Irp );
UCHAR minorFunction = irpStack->MinorFunction;
ULONG dockResult;
ULONG dockStatus;
PAGED_CODE();
dockDeviceExtension = deviceExtension->Dock.CorrospondingAcpiDevice ;
if (!dockDeviceExtension) {
ACPIDevPrint( (
ACPI_PRINT_FAILURE,
deviceExtension,
"(0x%08lx): ACPIDockIrpStartDevice - "
"no corresponding extension!!\n",
Irp
) );
ASSERT(0) ;
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL ;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return STATUS_UNSUCCESSFUL;
}
if (deviceExtension->Dock.IsolationState == IS_ISOLATED) {
KdDisableDebugger();
//
// Note: the way that this is structured is that we get
// the _DCK value first, and if that succeeds, then we
// get the device presence. If that also succeeds, then
// we try to process the two. If either fail, we don't
// do any work
//
status = ACPIGetIntegerEvalIntegerSync(
dockDeviceExtension,
PACKED_DCK,
1,
&dockResult
);
if (NT_SUCCESS(status)) {
//
// Get the device presence
//
status = ACPIGetDevicePresenceSync(
dockDeviceExtension,
(PVOID *) &dockStatus,
NULL
);
}
KdEnableDebugger();
if (NT_SUCCESS(status)) {
if (dockDeviceExtension->Flags & DEV_TYPE_NOT_PRESENT) {
if (dockResult != 0) {
ACPIDevPrint( (
ACPI_PRINT_FAILURE,
deviceExtension,
"(0x%08lx): ACPIDockIrpStartDevice: "
"Not present, but _DCK = %08lx\n",
Irp,
dockResult
) );
} else {
ACPIDevPrint( (
ACPI_PRINT_FAILURE,
deviceExtension,
"(0x%08lx): ACPIDockIrpStartDevice: _DCK = 0\n",
Irp
) );
}
status = STATUS_UNSUCCESSFUL ;
} else {
if (dockResult != 1) {
ACPIDevPrint( (
ACPI_PRINT_FAILURE,
deviceExtension,
"(0x%08lx): ACPIDockIrpStartDevice: _DCK = 0\n",
Irp
) );
} else {
ACPIDevPrint( (
ACPI_PRINT_IRP,
deviceExtension,
"(0x%08lx): ACPIDockIrpStartDevice = 0x%08lx\n",
Irp,
status
) );
}
}
}
//
// We are done. The ACPI implementers guide says we don't need to
// enumerate the entire tree here as the _DCK method should have
// notified the appropriate branches of the tree if the docking event
// was successful. Unfortunately Win2K behavior was to enumerate the
// entire tree. Specifically, it would drain starts before enums. Since
// the profile provider appeared at the top of the tree, the dock would
// start and then the enum that found it would proceed and find the
// hardware. To maintain this pseudo-behavior we queue an enum here
// (bletch.)
//
IoInvalidateDeviceRelations(
RootDeviceExtension->PhysicalDeviceObject,
BusRelations
);
//
// Now we remove the unattached dock flag, but only if we succeeded
// start. If we cleared it in the failure case, we couldn't eject the
// dock that may be physically attached. Note that this also means we
// *must* try to eject the dock after start failure! The proper code for
// this is part of the kernel.
//
if (NT_SUCCESS(status)) {
ACPIInternalUpdateFlags(
&(deviceExtension->Flags),
DEV_CAP_UNATTACHED_DOCK,
TRUE
);
}
}
if (NT_SUCCESS(status)) {
deviceExtension->Dock.IsolationState = IS_ISOLATION_DROPPED;
deviceExtension->DeviceState = Started;
}
Irp->IoStatus.Status = status;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return status;
}
BOOLEAN
ACPIDockIsDockDevice(
IN PNSOBJ AcpiObject
)
/*++
Routine Description:
This routine will tell the caller whether the given device is a dock.
Arguments:
The ACPI Object to test.
Return Value:
BOOLEAN (true iff dock)
--*/
{
PNSOBJ dckMethodObject ;
//
// ACPI dock devices are identified via _DCK methods.
//
return (NT_SUCCESS(ACPIDockGetDockObject(AcpiObject, &dckMethodObject))) ;
}
NTSTATUS
ACPIDockIrpSetPower(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine handles request to set the power state for a Physical
Device object
Arguments:
DeviceObject - The PDO target of the request
Irp - The request
Return Value:
NTSTATUS
--*/
{
NTSTATUS status;
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation( Irp );
UCHAR minorFunction = irpSp->MinorFunction;
if (irpSp->Parameters.Power.Type != SystemPowerState) {
return ACPIDockIrpSetDevicePower(DeviceObject, Irp);
} else {
return ACPIDockIrpSetSystemPower(DeviceObject, Irp);
}
}
NTSTATUS
ACPIDockIrpSetDevicePower(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine handles device power request for a dock PDO
Arguments:
DeviceObject - The PDO target
Irp - The request
IrpStack - The current request
Return Value:
NTSTATUS
--*/
{
NTSTATUS status;
PDEVICE_EXTENSION deviceExtension;
//
// Get the device extension
//
deviceExtension = ACPIInternalGetDeviceExtension( DeviceObject );
//
// We are going to do some work on the irp, so mark it as being
// successfull for now
//
Irp->IoStatus.Status = STATUS_SUCCESS;
//
// Mark the irp as pending
//
IoMarkIrpPending( Irp );
//
// We might queue up the irp, so this counts as a completion routine.
// Which means we need to incr the ref count
//
InterlockedIncrement( &deviceExtension->OutstandingIrpCount );
//
// Queue the irp up. Note that we will *always* call the completion
// routine, so we don't really care what was returned directly by
// this call --- the callback gets a chance to execute.
//
status = ACPIDeviceIrpDeviceRequest(
DeviceObject,
Irp,
ACPIDeviceIrpCompleteRequest
);
//
// Did we return STATUS_MORE_PROCESSING_REQUIRED (which we used
// if we overload STATUS_PENDING)
//
if (status == STATUS_MORE_PROCESSING_REQUIRED) {
status = STATUS_PENDING;
}
//
// Note: We called the completion routine, which should have completed
// the IRP with the same STATUS code as is being returned here (okay, if
// it is STATUS_PENDING, obviously we haven't completed the IRP, but that
// is okay).
//
return status;
}
NTSTATUS
ACPIDockIrpSetSystemPower(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine handles request to set the system power state for a Physical
Device object. Here we initiate warm ejects and act as a power policy
manager for ourselves.
Arguments:
DeviceObject - The PDO target of the request
Irp - The request
Return Value:
NTSTATUS
--*/
{
NTSTATUS status;
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation( Irp );
UCHAR minorFunction = irpSp->MinorFunction;
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(DeviceObject);
PDEVICE_EXTENSION dockDeviceExtension;
SYSTEM_POWER_STATE systemState;
DEVICE_POWER_STATE deviceState;
POWER_STATE powerState;
//
// Get the device extension
//
deviceExtension = ACPIInternalGetDeviceExtension( DeviceObject );
//
// Grab these two values. They are required for further calculations
//
systemState= irpSp->Parameters.Power.State.SystemState;
deviceState = deviceExtension->PowerInfo.DevicePowerMatrix[systemState];
dockDeviceExtension = deviceExtension->Dock.CorrospondingAcpiDevice ;
if (!dockDeviceExtension) {
ACPIDevPrint( (
ACPI_PRINT_FAILURE,
deviceExtension,
"(0x%08lx): ACPIDockIrpSetPower - "
"no corresponding extension!!\n",
Irp
) );
ASSERT(0) ;
return ACPIDispatchPowerIrpFailure( DeviceObject, Irp );
}
if (irpSp->Parameters.Power.ShutdownType == PowerActionWarmEject) {
//
// We are going to do some work on the irp, so mark it as being
// successful for now
//
Irp->IoStatus.Status = STATUS_SUCCESS;
//
// Mark the irp as pending
//
IoMarkIrpPending( Irp );
//
// We might queue up the irp, so this counts as a completion routine.
// Which means we need to incr the ref count
//
InterlockedIncrement( &dockDeviceExtension->OutstandingIrpCount );
ACPIDevPrint( (
ACPI_PRINT_REMOVE,
deviceExtension,
"(0x%08lx) ACPIBusIrpSetSystemPower: Eject from S%d!\n",
Irp,
systemState - PowerSystemWorking
) );
//
// Request the warm eject
//
status = ACPIDeviceIrpWarmEjectRequest(
dockDeviceExtension,
Irp,
ACPIDeviceIrpCompleteRequest,
(BOOLEAN) (deviceExtension->Dock.ProfileDepartureStyle == PDS_UPDATE_ON_EJECT)
);
//
// If we got back STATUS_MORE_PROCESSING_REQUIRED, then that is
// just an alias for STATUS_PENDING, so we make that change now
//
if (status == STATUS_MORE_PROCESSING_REQUIRED) {
status = STATUS_PENDING;
}
return status;
}
//
// Look at the device extension and determine if we need to send a
// D-irp in respond. The rule is that if the device is RAW driven or
// the current D state of the device is numerically lower then the
// known D state for the given S state, then we should send the request
//
ASSERT(deviceExtension->Flags & DEV_CAP_RAW);
if ( (deviceExtension->PowerInfo.PowerState == deviceState) ) {
return ACPIDispatchPowerIrpSuccess( DeviceObject, Irp );
} // if
ACPIDevPrint( (
ACPI_PRINT_REMOVE,
deviceExtension,
"(0x%08lx) ACPIDockIrpSetSystemPower: send D%d irp!\n",
Irp,
deviceState - PowerDeviceD0
) );
//
// We are going to do some work on the irp, so mark it as being
// successfull for now
//
Irp->IoStatus.Status = STATUS_SUCCESS;
//
// Mark the irp as pending
//
IoMarkIrpPending( Irp );
//
// We might queue up the irp, so this counts as a completion routine.
// Which means we need to incr the ref count
//
InterlockedIncrement( &deviceExtension->OutstandingIrpCount );
//
// We need to actually use a PowerState to send the request down, not
// a device state
//
powerState.DeviceState = deviceState;
//
// Make the request
//
PoRequestPowerIrp(
DeviceObject,
IRP_MN_SET_POWER,
powerState,
ACPIDockIrpSetSystemPowerComplete,
Irp,
NULL
);
//
// Always return pending
//
return STATUS_PENDING;
}
NTSTATUS
ACPIDockIrpSetSystemPowerComplete(
IN PDEVICE_OBJECT DeviceObject,
IN UCHAR MinorFunction,
IN POWER_STATE PowerState,
IN PVOID Context,
IN PIO_STATUS_BLOCK IoStatus
)
/*++
Routine Description:
This routine is called when the created D-irp has been sent throughout
the stack
Arguments:
DeviceObject - The device that received the request
MinorFunction - The function that was requested of the device
PowerState - The power state the device was sent to
Context - The original system irp
IoStatus - The result of the request
Return Value:
NTSTATUS
--*/
{
PIRP irp = (PIRP) Context;
PDEVICE_EXTENSION deviceExtension;
//
// Get the device extension
//
deviceExtension = ACPIInternalGetDeviceExtension( DeviceObject );
//
// Make sure that we have cleared the information field
//
irp->IoStatus.Information = 0;
//
// Call this wrapper function so that we don't have to duplicated code
//
ACPIDeviceIrpCompleteRequest(
deviceExtension,
(PVOID) irp,
IoStatus->Status
);
//
// Done
//
return IoStatus->Status;
}
VOID
ACPIDockIntfReference(
IN PVOID Context
)
/*++
Routine Description:
This routine increments the reference count for the dock interface
Arguments:
Context - The device object this interface was taken out against
Return Value:
None
--*/
{
PDEVICE_OBJECT deviceObject = (PDEVICE_OBJECT) Context;
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(deviceObject);
PAGED_CODE();
ObReferenceObject(deviceObject);
InterlockedIncrement(&deviceExtension->ReferenceCount);
if (!(deviceExtension->Flags & DEV_TYPE_SURPRISE_REMOVED)) {
InterlockedIncrement(&deviceExtension->Dock.InterfaceReferenceCount);
}
}
VOID
ACPIDockIntfDereference(
IN PVOID Context
)
/*++
Routine Description:
This routine decrements the reference count for the dock interface
Arguments:
Context - The device object this interface was taken out against
Return Value:
None
--*/
{
PDEVICE_OBJECT deviceObject = (PDEVICE_OBJECT) Context;
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(deviceObject);
ULONG oldReferenceCount;
PAGED_CODE();
if (!(deviceExtension->Flags & DEV_TYPE_SURPRISE_REMOVED)) {
oldReferenceCount = InterlockedDecrement(
&deviceExtension->Dock.InterfaceReferenceCount
);
if (oldReferenceCount == 0) {
//
// Revert back to the default used in buildsrc.c
//
deviceExtension->Dock.ProfileDepartureStyle = PDS_UPDATE_ON_EJECT;
}
}
oldReferenceCount = InterlockedDecrement(&deviceExtension->ReferenceCount);
if (oldReferenceCount == 0) {
//
// Delete the extension
//
ACPIInitDeleteDeviceExtension(deviceExtension);
}
ObDereferenceObject(deviceObject);
}
NTSTATUS
ACPIDockIntfSetMode(
IN PVOID Context,
IN PROFILE_DEPARTURE_STYLE Style
)
/*++
Routine Description:
This routine sets the manner in which profiles will be updated
Arguments:
Context - The device object this interface was taken out against
Style - PDS_UPDATE_ON_REMOVE, PDS_UPDATE_ON_EJECT,
PDS_UPDATE_ON_INTERFACE, or PDS_UPDATE_DEFAULT
Return Value:
NTSTATUS
--*/
{
PDEVICE_OBJECT deviceObject = (PDEVICE_OBJECT) Context;
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(deviceObject);
PAGED_CODE();
if (deviceExtension->Flags & DEV_TYPE_SURPRISE_REMOVED) {
return STATUS_NO_SUCH_DEVICE;
}
deviceExtension->Dock.ProfileDepartureStyle =
(Style == PDS_UPDATE_DEFAULT) ? PDS_UPDATE_ON_EJECT : Style;
ASSERT(deviceExtension->Dock.InterfaceReferenceCount);
return STATUS_SUCCESS;
}
NTSTATUS
ACPIDockIntfUpdateDeparture(
IN PVOID Context
)
/*++
Routine Description:
This routine initiates the hardware profile change portion of an undock
Arguments:
Context - The device object this interface was taken out against
Return Value:
NTSTATUS
--*/
{
PDEVICE_OBJECT deviceObject = (PDEVICE_OBJECT) Context;
PDEVICE_EXTENSION deviceExtension = ACPIInternalGetDeviceExtension(deviceObject);
NTSTATUS status;
ULONG ignoredPerSpec;
PDEVICE_EXTENSION dockDeviceExtension;
PAGED_CODE();
if (deviceExtension->Flags & DEV_TYPE_SURPRISE_REMOVED) {
return STATUS_NO_SUCH_DEVICE;
}
ASSERT(deviceExtension->Dock.InterfaceReferenceCount);
ASSERT(deviceExtension->Dock.ProfileDepartureStyle == PDS_UPDATE_ON_INTERFACE);
if (deviceExtension->Dock.ProfileDepartureStyle != PDS_UPDATE_ON_INTERFACE) {
//
// Can't do this, we may already have updated our profile!
//
return STATUS_INVALID_DEVICE_REQUEST;
}
//
// lets get the corrosponding dock node for this device
//
dockDeviceExtension = deviceExtension->Dock.CorrospondingAcpiDevice ;
//
// On the Compaq Armada 7800, we switch UARTs during an undock, thus we
// lose the debugger com port programming.
//
if (deviceExtension->Dock.IsolationState != IS_ISOLATED) {
KdDisableDebugger();
status = ACPIGetIntegerEvalIntegerSync(
dockDeviceExtension,
PACKED_DCK,
0,
&ignoredPerSpec
);
KdEnableDebugger();
deviceExtension->Dock.IsolationState = IS_ISOLATED;
}
else{
status = STATUS_SUCCESS;
}
return status;
}
Reference in a new issue Copy permalink