745 lines
22 KiB
C
745 lines
22 KiB
C
/*++
|
|
|
|
Copyright (c) 1998 - 1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
pnp.c
|
|
|
|
Abstract: This module contains PnP Start, Stop, Remove,
|
|
Power dispatch routines and IRP cancel routine.
|
|
|
|
Environment:
|
|
|
|
Kernel mode
|
|
|
|
@@BEGIN_DDKSPLIT
|
|
Author:
|
|
|
|
Eliyas Yakub (Mar, 11, 1997)
|
|
Revision History:
|
|
|
|
Updated by Eliyas on Feb 5 1998
|
|
Om Sharma ( April 15, 1998)
|
|
MarcAnd 02-Jul-98 Quick tidy for DDK
|
|
|
|
@@END_DDKSPLIT
|
|
--*/
|
|
|
|
#include "hidgame.h"
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text (PAGE, HGM_RemoveDevice)
|
|
#pragma alloc_text (PAGE, HGM_PnP)
|
|
#pragma alloc_text (PAGE, HGM_InitDevice)
|
|
#pragma alloc_text (PAGE, HGM_GetResources)
|
|
#pragma alloc_text (PAGE, HGM_Power)
|
|
#endif
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func NTSTATUS | HGM_IncRequestCount |
|
|
*
|
|
* Try to increment the request count but fail if the device is
|
|
* being removed.
|
|
*
|
|
* @parm IN PDEVICE_EXTENSION | DeviceExtension |
|
|
*
|
|
* Pointer to the device extension.
|
|
*
|
|
* @rvalue STATUS_SUCCESS | success
|
|
* @rvalue STATUS_DELETE_PENDING | PnP IRP received after device was removed
|
|
*
|
|
*****************************************************************************/
|
|
NTSTATUS EXTERNAL
|
|
HGM_IncRequestCount
|
|
(
|
|
IN PDEVICE_EXTENSION DeviceExtension
|
|
)
|
|
{
|
|
NTSTATUS ntStatus;
|
|
|
|
InterlockedIncrement( &DeviceExtension->RequestCount );
|
|
ASSERT( DeviceExtension->RequestCount > 0 );
|
|
|
|
if( DeviceExtension->fRemoved )
|
|
{
|
|
/*
|
|
* PnP has already told us to remove the device so fail and make
|
|
* sure that the event has been set.
|
|
*/
|
|
if( 0 == InterlockedDecrement( &DeviceExtension->RequestCount ) )
|
|
{
|
|
KeSetEvent( &DeviceExtension->RemoveEvent, IO_NO_INCREMENT, FALSE );
|
|
}
|
|
ntStatus = STATUS_DELETE_PENDING;
|
|
}
|
|
else
|
|
{
|
|
ntStatus = STATUS_SUCCESS;
|
|
}
|
|
|
|
return ntStatus;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func VOID | HGM_DecRequestCount |
|
|
*
|
|
* Decrement the request count and set event if this is the last.
|
|
*
|
|
* @parm IN PDEVICE_EXTENSION | DeviceExtension |
|
|
*
|
|
* Pointer to the device extension.
|
|
*
|
|
*****************************************************************************/
|
|
VOID EXTERNAL
|
|
HGM_DecRequestCount
|
|
(
|
|
IN PDEVICE_EXTENSION DeviceExtension
|
|
)
|
|
{
|
|
LONG LocalCount;
|
|
|
|
LocalCount = InterlockedDecrement( &DeviceExtension->RequestCount );
|
|
|
|
ASSERT( DeviceExtension->RequestCount >= 0 );
|
|
|
|
if( LocalCount == 0 )
|
|
{
|
|
/*
|
|
* PnP has already told us to remove the device so the PnP remove
|
|
* code should have set device as removed and should be waiting on
|
|
* the event.
|
|
*/
|
|
ASSERT( DeviceExtension->fRemoved );
|
|
KeSetEvent( &DeviceExtension->RemoveEvent, IO_NO_INCREMENT, FALSE );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func VOID | HGM_RemoveDevice |
|
|
*
|
|
* FDO Remove routine
|
|
*
|
|
* @parm IN PDEVICE_EXTENSION | DeviceExtension |
|
|
*
|
|
* Pointer to the device extension.
|
|
*
|
|
*****************************************************************************/
|
|
VOID INTERNAL
|
|
HGM_RemoveDevice
|
|
(
|
|
PDEVICE_EXTENSION DeviceExtension
|
|
)
|
|
{
|
|
if (DeviceExtension->fSurpriseRemoved) {
|
|
return;
|
|
}
|
|
|
|
DeviceExtension->fSurpriseRemoved = TRUE;
|
|
|
|
/*
|
|
* Acquire mutex before modifying the Global Linked list of devices
|
|
*/
|
|
ExAcquireFastMutex (&Global.Mutex);
|
|
|
|
/*
|
|
* Remove this device from the linked list of devices
|
|
*/
|
|
RemoveEntryList(&DeviceExtension->Link);
|
|
|
|
/*
|
|
* Release the mutex
|
|
*/
|
|
ExReleaseFastMutex (&Global.Mutex);
|
|
} /* HGM_RemoveDevice */
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func NTSTATUS | HGM_PnP |
|
|
*
|
|
* Plug and Play dispatch routine for this driver.
|
|
*
|
|
* @parm IN PDEVICE_OBJECT | DeviceObject |
|
|
*
|
|
* Pointer to the device object.
|
|
*
|
|
* @parm IN PIRP | Irp |
|
|
*
|
|
* Pointer to an I/O request packet.
|
|
*
|
|
* @rvalue STATUS_SUCCESS | success
|
|
* @rvalue STATUS_DELETE_PENDING | PnP IRP received after device was removed
|
|
* @rvalue ??? | Return from IoCallDriver() or HGM_InitDevice()
|
|
*
|
|
*****************************************************************************/
|
|
NTSTATUS EXTERNAL
|
|
HGM_PnP
|
|
(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
{
|
|
NTSTATUS ntStatus;
|
|
PDEVICE_EXTENSION DeviceExtension;
|
|
KEVENT StartEvent;
|
|
|
|
PAGED_CODE();
|
|
|
|
HGM_DBGPRINT(FILE_PNP | HGM_FENTRY,\
|
|
("HGM_PnP(DeviceObject=0x%x,Irp=0x%x)",\
|
|
DeviceObject, Irp ));
|
|
/*
|
|
* Get a pointer to the device extension
|
|
*/
|
|
DeviceExtension = GET_MINIDRIVER_DEVICE_EXTENSION(DeviceObject);
|
|
|
|
ntStatus = HGM_IncRequestCount( DeviceExtension );
|
|
if (!NT_SUCCESS (ntStatus))
|
|
{
|
|
/*
|
|
* Someone sent us another plug and play IRP after removed
|
|
*/
|
|
|
|
HGM_DBGPRINT(FILE_PNP | HGM_ERROR,\
|
|
("HGM_PnP: PnP IRP after device was removed\n"));
|
|
Irp->IoStatus.Information = 0;
|
|
Irp->IoStatus.Status = ntStatus;
|
|
IoCompleteRequest (Irp, IO_NO_INCREMENT);
|
|
} else
|
|
{
|
|
PIO_STACK_LOCATION IrpStack;
|
|
|
|
/*
|
|
* Get a pointer to the current location in the Irp
|
|
*/
|
|
IrpStack = IoGetCurrentIrpStackLocation (Irp);
|
|
|
|
switch(IrpStack->MinorFunction)
|
|
{
|
|
case IRP_MN_START_DEVICE:
|
|
|
|
HGM_DBGPRINT(FILE_PNP | HGM_BABBLE,\
|
|
("HGM_Pnp: IRP_MN_START_DEVICE"));
|
|
/*
|
|
* We cannot touch the device (send it any non pnp irps) until a
|
|
* start device has been passed down to the lower drivers.
|
|
*/
|
|
KeInitializeEvent(&StartEvent, NotificationEvent, FALSE);
|
|
|
|
IoCopyCurrentIrpStackLocationToNext (Irp);
|
|
IoSetCompletionRoutine (Irp, HGM_PnPComplete, &StartEvent, TRUE, TRUE, TRUE);
|
|
ntStatus = IoCallDriver (GET_NEXT_DEVICE_OBJECT(DeviceObject), Irp);
|
|
|
|
if( NT_SUCCESS(ntStatus ) )
|
|
{
|
|
ntStatus = KeWaitForSingleObject
|
|
(
|
|
&StartEvent,
|
|
Executive, /* Waiting for reason of a driver */
|
|
KernelMode, /* Waiting in kernel mode */
|
|
FALSE, /* No allert */
|
|
NULL /* No timeout */
|
|
);
|
|
}
|
|
|
|
if(NT_SUCCESS(ntStatus))
|
|
{
|
|
ntStatus = Irp->IoStatus.Status;
|
|
}
|
|
|
|
if(NT_SUCCESS (ntStatus))
|
|
{
|
|
/*
|
|
* As we are now back from our start device we can do work.
|
|
*/
|
|
ntStatus = HGM_InitDevice (DeviceObject, Irp);
|
|
} else
|
|
{
|
|
HGM_DBGPRINT(FILE_PNP | HGM_ERROR,\
|
|
("HGM_Pnp: IRP_MN_START_DEVICE ntStatus =0x%x",\
|
|
ntStatus));
|
|
}
|
|
|
|
|
|
DeviceExtension->fStarted = TRUE;
|
|
|
|
/*
|
|
* Return Status
|
|
*/
|
|
Irp->IoStatus.Information = 0;
|
|
Irp->IoStatus.Status = ntStatus;
|
|
IoCompleteRequest (Irp, IO_NO_INCREMENT);
|
|
|
|
break;
|
|
|
|
case IRP_MN_STOP_DEVICE:
|
|
|
|
HGM_DBGPRINT(FILE_PNP | HGM_BABBLE,\
|
|
("HGM_Pnp: IRP_MN_STOP_DEVICE"));
|
|
/*
|
|
* After the start IRP has been sent to the lower driver object, the bus may
|
|
* NOT send any more IRPS down ``touch'' until another START has occured.
|
|
* Whatever access is required must be done before Irp passed on.
|
|
*/
|
|
|
|
DeviceExtension->fStarted = FALSE;
|
|
|
|
/*
|
|
* We don't need a completion routine so fire and forget.
|
|
* Set the current stack location to the next stack location and
|
|
* call the next device object.
|
|
*/
|
|
|
|
IoSkipCurrentIrpStackLocation (Irp);
|
|
ntStatus = IoCallDriver (GET_NEXT_DEVICE_OBJECT(DeviceObject), Irp);
|
|
break;
|
|
|
|
case IRP_MN_SURPRISE_REMOVAL:
|
|
HGM_DBGPRINT(FILE_PNP | HGM_BABBLE,\
|
|
("HGM_Pnp: IRP_MN_SURPRISE_REMOVAL"));
|
|
|
|
HGM_RemoveDevice(DeviceExtension);
|
|
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
IoSkipCurrentIrpStackLocation(Irp);
|
|
ntStatus = IoCallDriver (GET_NEXT_DEVICE_OBJECT(DeviceObject), Irp);
|
|
|
|
break;
|
|
|
|
case IRP_MN_REMOVE_DEVICE:
|
|
HGM_DBGPRINT(FILE_PNP | HGM_BABBLE,\
|
|
("HGM_Pnp: IRP_MN_REMOVE_DEVICE"));
|
|
|
|
/*
|
|
* The PlugPlay system has dictacted the removal of this device. We
|
|
* have no choice but to detach and delete the device object.
|
|
* (If we wanted to express an interest in preventing this removal,
|
|
* we should have filtered the query remove and query stop routines.)
|
|
* Note: we might receive a remove WITHOUT first receiving a stop.
|
|
*/
|
|
|
|
/*
|
|
* Make sure we do not allow more IRPs to start touching the device
|
|
*/
|
|
DeviceExtension->fRemoved = TRUE;
|
|
|
|
/*
|
|
* Stop the device without touching the hardware.
|
|
*/
|
|
HGM_RemoveDevice(DeviceExtension);
|
|
|
|
/*
|
|
* Send on the remove IRP
|
|
*/
|
|
IoSkipCurrentIrpStackLocation (Irp);
|
|
ntStatus = IoCallDriver (GET_NEXT_DEVICE_OBJECT(DeviceObject), Irp);
|
|
|
|
|
|
/*
|
|
* Remove this IRPs hold which should leave the initial 1 plus
|
|
* any other IRP holds.
|
|
*/
|
|
{
|
|
LONG RequestCount = InterlockedDecrement( &DeviceExtension->RequestCount );
|
|
ASSERT( RequestCount > 0 );
|
|
}
|
|
|
|
/*
|
|
* If someone has already started, wait for them to finish
|
|
*/
|
|
if( InterlockedDecrement( &DeviceExtension->RequestCount ) > 0 )
|
|
{
|
|
KeWaitForSingleObject( &DeviceExtension->RemoveEvent,
|
|
Executive, KernelMode, FALSE, NULL );
|
|
}
|
|
|
|
ntStatus = STATUS_SUCCESS;
|
|
|
|
HGM_EXITPROC(FILE_IOCTL|HGM_FEXIT_STATUSOK, "HGM_PnP Exit 1", ntStatus);
|
|
|
|
return ntStatus;
|
|
|
|
default:
|
|
HGM_DBGPRINT(FILE_PNP | HGM_WARN,\
|
|
("HGM_PnP: IrpStack->MinorFunction Not handled 0x%x", \
|
|
IrpStack->MinorFunction));
|
|
|
|
IoSkipCurrentIrpStackLocation (Irp);
|
|
|
|
ntStatus = IoCallDriver(GET_NEXT_DEVICE_OBJECT(DeviceObject), Irp);
|
|
break;
|
|
}
|
|
|
|
HGM_DecRequestCount( DeviceExtension );
|
|
}
|
|
|
|
HGM_EXITPROC(FILE_IOCTL|HGM_FEXIT, "HGM_PnP", ntStatus);
|
|
|
|
return ntStatus;
|
|
} /* HGM_PnP */
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func NTSTATUS | HGM_InitDevice |
|
|
*
|
|
* Get the device information and attempt to initialize a configuration
|
|
* for a device. If we cannot identify this as a valid HID device or
|
|
* configure the device, our start device function is failed.
|
|
*
|
|
* @parm IN PDEVICE_OBJECT | DeviceObject |
|
|
*
|
|
* Pointer to the device object.
|
|
*
|
|
* @parm IN PIRP | Irp |
|
|
*
|
|
* Pointer to an I/O request packet.
|
|
*
|
|
* @rvalue STATUS_SUCCESS | success
|
|
* @rvalue STATUS_DEVICE_CONFIGURATION_ERROR | Resources overlap
|
|
* @rvalue ??? | Return from HGM_GetResources() or HGM_JoystickConfig()
|
|
*
|
|
*
|
|
*****************************************************************************/
|
|
NTSTATUS INTERNAL
|
|
HGM_InitDevice
|
|
(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
{
|
|
NTSTATUS ntStatus;
|
|
PDEVICE_EXTENSION DeviceExtension;
|
|
ULONG DescriptorLength;
|
|
|
|
PAGED_CODE();
|
|
|
|
HGM_DBGPRINT(FILE_PNP | HGM_FENTRY,\
|
|
("HGM_InitDevice(DeviceObject=0x%x,Irp=0x%x)", \
|
|
DeviceObject,Irp));
|
|
|
|
/*
|
|
* Get a pointer to the device extension
|
|
*/
|
|
DeviceExtension = GET_MINIDRIVER_DEVICE_EXTENSION(DeviceObject);
|
|
|
|
/*
|
|
* Get resource information from GameEnum and store it in the device extension
|
|
*/
|
|
ntStatus = HGM_GetResources(DeviceObject,Irp);
|
|
if( NT_SUCCESS(ntStatus) )
|
|
{
|
|
ntStatus = HGM_InitAnalog(DeviceObject);
|
|
}
|
|
else
|
|
{
|
|
HGM_DBGPRINT(FILE_PNP | HGM_ERROR,\
|
|
("HGM_InitDevice: HGM_GetResources Failed"));
|
|
}
|
|
|
|
if( !NT_SUCCESS(ntStatus) )
|
|
{
|
|
/*
|
|
* Acquire mutex before modifying the Global Linked list of devices
|
|
*/
|
|
ExAcquireFastMutex (&Global.Mutex);
|
|
|
|
/*
|
|
* Remove this device from the linked list of devices
|
|
*/
|
|
RemoveEntryList(&DeviceExtension->Link);
|
|
|
|
/*
|
|
* Release the mutex
|
|
*/
|
|
ExReleaseFastMutex (&Global.Mutex);
|
|
}
|
|
|
|
HGM_EXITPROC(FILE_IOCTL|HGM_FEXIT_STATUSOK, "HGM_InitDevice", ntStatus);
|
|
|
|
return ntStatus;
|
|
} /* HGM_InitDevice */
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func NTSTATUS | HGM_GetResources |
|
|
*
|
|
* Gets gameport resource information from the GameEnum driver
|
|
*
|
|
* @parm IN PDEVICE_OBJECT | DeviceObject |
|
|
*
|
|
* Pointer to the device object.
|
|
*
|
|
* @parm IN PIRP | Irp |
|
|
*
|
|
* Pointer to an I/O request packet.
|
|
*
|
|
* @rvalue STATUS_SUCCESS | success
|
|
* @rvalue ??? | Return from IoCallDriver()
|
|
*
|
|
*****************************************************************************/
|
|
NTSTATUS INTERNAL
|
|
HGM_GetResources
|
|
(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
{
|
|
NTSTATUS ntStatus = STATUS_SUCCESS;
|
|
GAMEENUM_PORT_PARAMETERS PortInfo;
|
|
POEMDATA OemData;
|
|
PDEVICE_EXTENSION DeviceExtension;
|
|
KEVENT IoctlCompleteEvent;
|
|
IO_STATUS_BLOCK IoStatus;
|
|
PIO_STACK_LOCATION irpStack, nextStack;
|
|
int i;
|
|
PAGED_CODE ();
|
|
|
|
HGM_DBGPRINT(FILE_PNP | HGM_FENTRY,\
|
|
("HGM_GetResources(DeviceObject=0x%x,Irp=0x%x)",\
|
|
DeviceObject, Irp));
|
|
|
|
/*
|
|
* Get a pointer to the device extension
|
|
*/
|
|
|
|
DeviceExtension = GET_MINIDRIVER_DEVICE_EXTENSION(DeviceObject);
|
|
|
|
|
|
/*
|
|
* issue a synchronous request to get the resources info from GameEnum
|
|
*/
|
|
|
|
KeInitializeEvent(&IoctlCompleteEvent, NotificationEvent, FALSE);
|
|
|
|
irpStack = IoGetCurrentIrpStackLocation(Irp);
|
|
nextStack = IoGetNextIrpStackLocation(Irp);
|
|
ASSERTMSG("HGM_GetResources:",nextStack != NULL);
|
|
|
|
/*
|
|
* pass the Portinfo buffer of the DeviceExtension
|
|
*/
|
|
|
|
nextStack->MajorFunction =
|
|
IRP_MJ_INTERNAL_DEVICE_CONTROL;
|
|
|
|
nextStack->Parameters.DeviceIoControl.IoControlCode =
|
|
IOCTL_GAMEENUM_PORT_PARAMETERS;
|
|
|
|
PortInfo.Size =
|
|
nextStack->Parameters.DeviceIoControl.InputBufferLength =
|
|
nextStack->Parameters.DeviceIoControl.OutputBufferLength =
|
|
sizeof (PortInfo);
|
|
|
|
Irp->UserBuffer = &PortInfo;
|
|
|
|
IoSetCompletionRoutine (Irp, HGM_PnPComplete,
|
|
&IoctlCompleteEvent, TRUE, TRUE, TRUE);
|
|
|
|
HGM_DBGPRINT(FILE_PNP | HGM_BABBLE,\
|
|
("calling GameEnum"));
|
|
|
|
ntStatus = IoCallDriver(GET_NEXT_DEVICE_OBJECT (DeviceObject), Irp);
|
|
|
|
if( NT_SUCCESS(ntStatus) )
|
|
{
|
|
ntStatus = KeWaitForSingleObject(
|
|
&IoctlCompleteEvent,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
|
|
}
|
|
|
|
if( NT_SUCCESS(ntStatus) )
|
|
{
|
|
ntStatus = Irp->IoStatus.Status;
|
|
}
|
|
DeviceExtension->GameContext = PortInfo.GameContext;
|
|
DeviceExtension->ReadAccessor = PortInfo.ReadAccessor;
|
|
DeviceExtension->WriteAccessor = PortInfo.WriteAccessor;
|
|
DeviceExtension->ReadAccessorDigital= PortInfo.ReadAccessorDigital;
|
|
DeviceExtension->AcquirePort = PortInfo.AcquirePort;
|
|
DeviceExtension->ReleasePort = PortInfo.ReleasePort;
|
|
DeviceExtension->PortContext = PortInfo.PortContext;
|
|
DeviceExtension->nAxes = PortInfo.NumberAxis;
|
|
DeviceExtension->nButtons = PortInfo.NumberButtons;
|
|
|
|
#ifdef CHANGE_DEVICE
|
|
/*
|
|
* Stash the NextDeviceObject in the device extension so that we can
|
|
* call GameEnum IRPs when we're not responding to an IRP
|
|
*/
|
|
DeviceExtension->NextDeviceObject = GET_NEXT_DEVICE_OBJECT(DeviceObject);
|
|
#endif /* CHANGE_DEVICE */
|
|
|
|
RtlCopyMemory(DeviceExtension->HidGameOemData.Game_Oem_Data, PortInfo.OemData, sizeof(PortInfo.OemData));
|
|
|
|
for(i=0x0;
|
|
i < sizeof(PortInfo.OemData)/sizeof(PortInfo.OemData[0]);
|
|
i++)
|
|
{
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_BABBLE2,\
|
|
("JoystickConfig: PortInfo.OemData[%d]=0x%x",\
|
|
i, PortInfo.OemData[i]) );
|
|
}
|
|
|
|
|
|
HGM_EXITPROC(FILE_IOCTL|HGM_FEXIT_STATUSOK, "HGM_GetResources", Irp->IoStatus.Status);
|
|
|
|
return Irp->IoStatus.Status;
|
|
} /* HGM_GetResources */
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func NTSTATUS | HGM_PnPComplete |
|
|
*
|
|
* Completion routine for PnP IRPs.
|
|
* Not pageable because it is a completion routine.
|
|
*
|
|
* @parm IN PDEVICE_OBJECT | DeviceObject |
|
|
*
|
|
* Pointer to the device object.
|
|
*
|
|
* @parm IN PIRP | Irp |
|
|
*
|
|
* Pointer to an I/O request packet.
|
|
*
|
|
* @rvalue STATUS_MORE_PROCESSING_REQUIRED | We want the IRP back
|
|
*
|
|
*****************************************************************************/
|
|
NTSTATUS INTERNAL
|
|
HGM_PnPComplete
|
|
(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PVOID Context
|
|
)
|
|
{
|
|
NTSTATUS ntStatus = STATUS_MORE_PROCESSING_REQUIRED;
|
|
|
|
HGM_DBGPRINT(FILE_PNP | HGM_FENTRY,\
|
|
("HGM_PnPComplete(DeviceObject=0x%x,Irp=0x%x,Context=0x%x)", \
|
|
DeviceObject, Irp, Context));
|
|
|
|
UNREFERENCED_PARAMETER (DeviceObject);
|
|
KeSetEvent ((PKEVENT) Context, 0, FALSE);
|
|
|
|
HGM_EXITPROC(FILE_IOCTL|HGM_FEXIT, "HGM_PnpComplete", ntStatus);
|
|
|
|
return ntStatus;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func NTSTATUS | HGM_Power |
|
|
*
|
|
* The power dispatch routine.
|
|
* <nl>This driver does not recognize power IRPS. It merely sends them down,
|
|
* unmodified to the next device on the attachment stack.
|
|
* As this is a POWER irp, and therefore a special irp, special power irp
|
|
* handling is required. No completion routine is required.
|
|
*
|
|
* @parm IN PDEVICE_OBJECT | DeviceObject |
|
|
*
|
|
* Pointer to the device object.
|
|
*
|
|
* @parm IN PIRP | Irp |
|
|
*
|
|
* Pointer to an I/O request packet.
|
|
*
|
|
*
|
|
* @rvalue STATUS_SUCCESS | success
|
|
* @rvalue ??? | Return from PoCallDriver()
|
|
*
|
|
*****************************************************************************/
|
|
NTSTATUS INTERNAL
|
|
HGM_Power
|
|
(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
{
|
|
PDEVICE_EXTENSION DeviceExtension;
|
|
NTSTATUS ntStatus;
|
|
|
|
PAGED_CODE ();
|
|
|
|
HGM_DBGPRINT(FILE_PNP | HGM_FENTRY,\
|
|
("Enter HGM_Power(DeviceObject=0x%x,Irp=0x%x)",DeviceObject, Irp));
|
|
|
|
DeviceExtension = GET_MINIDRIVER_DEVICE_EXTENSION (DeviceObject);
|
|
|
|
/*
|
|
* Since we do not know what to do with the IRP, we should pass
|
|
* it on along down the stack.
|
|
*/
|
|
|
|
ntStatus = HGM_IncRequestCount( DeviceExtension );
|
|
if (!NT_SUCCESS (ntStatus))
|
|
{
|
|
/*
|
|
* Someone sent us another plug and play IRP after removed
|
|
*/
|
|
|
|
HGM_DBGPRINT(FILE_PNP | HGM_ERROR,\
|
|
("HGM_Power: PnP IRP after device was removed\n"));
|
|
Irp->IoStatus.Information = 0;
|
|
Irp->IoStatus.Status = ntStatus;
|
|
IoCompleteRequest (Irp, IO_NO_INCREMENT);
|
|
} else
|
|
{
|
|
IoSkipCurrentIrpStackLocation (Irp);
|
|
|
|
/*
|
|
* Power IRPS come synchronously; drivers must call
|
|
* PoStartNextPowerIrp, when they are ready for the next power irp.
|
|
* This can be called here, or in the completetion routine.
|
|
*/
|
|
PoStartNextPowerIrp (Irp);
|
|
|
|
/*
|
|
* NOTE!!! PoCallDriver NOT IoCallDriver.
|
|
*/
|
|
ntStatus = PoCallDriver (GET_NEXT_DEVICE_OBJECT (DeviceObject), Irp);
|
|
|
|
HGM_DecRequestCount( DeviceExtension );
|
|
}
|
|
|
|
|
|
HGM_EXITPROC(FILE_IOCTL | HGM_FEXIT, "HGM_Power", ntStatus);
|
|
return ntStatus;
|
|
} /* HGM_Power */
|
|
|