/*++ 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. * 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 */