/*++
Copyright (c) 2000 Microsoft Corporation
Module Name:
pnp.c
Abstract: This module contains code to handle PnP and Power IRPs.
Environment:
Kernel mode
Author:
Michael Tsang (MikeTs) 13-Apr-2000
Revision History:
--*/
#include "pch.h"
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, HbutPnp)
#pragma alloc_text(PAGE, HbutPower)
#pragma alloc_text(PAGE, StartDevice)
#pragma alloc_text(PAGE, RemoveDevice)
#pragma alloc_text(PAGE, SendSyncIrp)
#endif
/*****************************************************************************
*
* @doc EXTERNAL
*
* @func NTSTATUS | HbutPnp |
* Plug and Play dispatch routine for this driver.
*
* @parm IN PDEVICE_OBJECT | DevObj | Pointer to the device object.
* @parm IN PIRP | Irp | Pointer to an I/O request packet.
*
* @rvalue SUCCESS | returns STATUS_SUCCESS
* @rvalue FAILURE | returns NT status code
*
*****************************************************************************/
NTSTATUS EXTERNAL
HbutPnp(
IN PDEVICE_OBJECT DevObj,
IN PIRP Irp
)
{
PROCNAME("HbutPnp")
NTSTATUS status;
PIO_STACK_LOCATION irpsp;
PDEVICE_EXTENSION devext;
PAGED_CODE();
irpsp = IoGetCurrentIrpStackLocation(Irp);
ENTER(1, ("(DevObj=%p,Irp=%p,IrpSp=%p,Minor=%s)\n",
DevObj, Irp, irpsp,
LookupName(irpsp->MinorFunction, PnPMinorFnNames)));
devext = GET_MINIDRIVER_DEVICE_EXTENSION(DevObj);
status = IoAcquireRemoveLock(&devext->RemoveLock, Irp);
if (!NT_SUCCESS(status))
{
//
// Someone sent us another plug and play IRP after removed
//
ERRPRINT(("received PnP IRP after device was removed\n"));
Irp->IoStatus.Information = 0;
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
else
{
BOOLEAN fSkipIt = FALSE;
switch (irpsp->MinorFunction)
{
case IRP_MN_START_DEVICE:
ASSERT(!(devext->dwfHBut & HBUTF_DEVICE_STARTED));
//
// Forward the IRP down the stack
//
status = SendSyncIrp(GET_NEXT_DEVICE_OBJECT(DevObj), Irp, TRUE);
if (NT_SUCCESS(status))
{
status = StartDevice(DevObj, Irp);
if (NT_SUCCESS(status))
{
devext->dwfHBut |= HBUTF_DEVICE_STARTED;
}
}
else
{
ERRPRINT(("failed to forward start IRP (status=%x)\n",
status));
}
Irp->IoStatus.Information = 0;
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
case 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.
//
if (devext->dwfHBut & HBUTF_DEVICE_STARTED)
{
devext->dwfHBut &= ~HBUTF_DEVICE_STARTED;
if (devext->dwfHBut & HBUTF_INTERRUPT_CONNECTED)
{
IoDisconnectInterrupt(devext->InterruptObject);
devext->dwfHBut &= ~HBUTF_INTERRUPT_CONNECTED;
}
}
//
// 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.
//
fSkipIt = TRUE;
Irp->IoStatus.Status = STATUS_SUCCESS;
break;
case IRP_MN_REMOVE_DEVICE:
case IRP_MN_SURPRISE_REMOVAL:
//
// The PlugPlay system has detected 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.
//
devext->dwfHBut &= ~HBUTF_DEVICE_STARTED;
devext->dwfHBut |= HBUTF_DEVICE_REMOVED;
RemoveDevice(DevObj, Irp);
//
// Send on the remove IRP
//
fSkipIt = TRUE;
Irp->IoStatus.Status = STATUS_SUCCESS;
break;
case IRP_MN_QUERY_CAPABILITIES:
status = SendSyncIrp(GET_NEXT_DEVICE_OBJECT(DevObj), Irp, TRUE);
if (NT_SUCCESS(status))
{
PDEVICE_CAPABILITIES devcaps;
devcaps = irpsp->Parameters.DeviceCapabilities.Capabilities;
if (devcaps != NULL)
{
SYSTEM_POWER_STATE i;
//
// This device is built-in to the system, so it should
// be impossible to surprise remove this device, but
// we will handle it anyway.
//
devcaps->SurpriseRemovalOK = TRUE;
//
// While the underlying serial bus might be able to
// wake the machine from low power (via wake on ring),
// the tablet cannot.
//
devcaps->SystemWake = PowerSystemUnspecified;
devcaps->DeviceWake = PowerDeviceUnspecified;
devcaps->WakeFromD0 =
devcaps->WakeFromD1 =
devcaps->WakeFromD2 =
devcaps->WakeFromD3 = FALSE;
devcaps->DeviceState[PowerSystemWorking] =
PowerDeviceD0;
for (i = PowerSystemSleeping1;
i < PowerSystemMaximum;
i++)
{
devcaps->DeviceState[i] = PowerDeviceD3;
}
}
}
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
default:
fSkipIt = TRUE;
break;
}
if (fSkipIt)
{
IoSkipCurrentIrpStackLocation(Irp);
ENTER(2, (".IoCallDriver(DevObj=%p,Irp=%p)\n",
GET_NEXT_DEVICE_OBJECT(DevObj), Irp));
status = IoCallDriver(GET_NEXT_DEVICE_OBJECT(DevObj), Irp);
EXIT(2, (".IoCallDriver=%x\n", status));
}
if (irpsp->MinorFunction == IRP_MN_REMOVE_DEVICE)
{
//
// Wait for the remove lock to free.
//
IoReleaseRemoveLockAndWait(&devext->RemoveLock, Irp);
}
else
{
IoReleaseRemoveLock(&devext->RemoveLock, Irp);
}
}
EXIT(1, ("=%x\n", status));
return status;
} //HbutPnp
/*****************************************************************************
*
* @doc EXTERNAL
*
* @func NTSTATUS | HbutPower | The power dispatch routine for this driver.
*
* @parm IN PDEVICE_OBJECT | DevObj | Points to the device object.
* @parm IN PIRP | Irp | Points to an I/O request packet.
*
* @rvalue SUCCESS | returns STATUS_SUCCESS
* @rvalue FAILURE | returns NT status code
*
*****************************************************************************/
NTSTATUS EXTERNAL
HbutPower(
IN PDEVICE_OBJECT DevObj,
IN PIRP Irp
)
{
PROCNAME("HbutPower")
NTSTATUS status;
PDEVICE_EXTENSION devext;
PAGED_CODE();
ENTER(1, ("(DevObj=%p,Irp=%p,Minor=%s)\n",
DevObj, Irp,
LookupName(IoGetCurrentIrpStackLocation(Irp)->MinorFunction,
PowerMinorFnNames)));
devext = GET_MINIDRIVER_DEVICE_EXTENSION(DevObj);
status = IoAcquireRemoveLock(&devext->RemoveLock, Irp);
if (!NT_SUCCESS(status))
{
//
// Someone sent us another power IRP after removed
//
ERRPRINT(("received Power IRP after device was removed\n"));
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
else
{
IoSkipCurrentIrpStackLocation(Irp);
ENTER(2, (".PoCallDriver(DevObj=%p,Irp=%p)\n",
GET_NEXT_DEVICE_OBJECT(DevObj), Irp));
status = PoCallDriver(GET_NEXT_DEVICE_OBJECT(DevObj), Irp);
EXIT(2, (".PoCallDriver=%x\n", status));
IoReleaseRemoveLock(&devext->RemoveLock, Irp);
}
EXIT(1, ("=%x\n", status));
return status;
} //HbutPower
/*****************************************************************************
*
* @doc INTERNAL
*
* @func NTSTATUS | StartDevice |
* 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 | DevObj | Points to the device object.
* @parm IN PIRP | Irp | Points to an I/O request packet.
*
* @rvalue SUCCESS | returns STATUS_SUCCESS
* @rvalue FAILURE | returns NT status code
*
*****************************************************************************/
NTSTATUS INTERNAL
StartDevice(
IN PDEVICE_OBJECT DevObj,
IN PIRP Irp
)
{
PROCNAME("StartDevice")
NTSTATUS status = STATUS_SUCCESS;
PIO_STACK_LOCATION irpsp;
PDEVICE_EXTENSION devext;
PAGED_CODE();
ENTER(2, ("(DevObj=%p,Irp=%p)\n", DevObj, Irp));
irpsp = IoGetCurrentIrpStackLocation(Irp);
devext = GET_MINIDRIVER_DEVICE_EXTENSION(DevObj);
if (irpsp->Parameters.StartDevice.AllocatedResourcesTranslated == NULL)
{
ERRPRINT(("no resources is allocated to the button device!\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
}
else
{
ULONG Count;
PCM_PARTIAL_RESOURCE_DESCRIPTOR pDesc;
Count = 0;
pDesc = RtlUnpackPartialDesc(
CmResourceTypePort,
irpsp->Parameters.StartDevice.AllocatedResourcesTranslated,
&Count);
if (pDesc == NULL)
{
ERRPRINT(("no allocated port resources!\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
}
else
{
devext->IORes = *pDesc;
Count = 0;
pDesc = RtlUnpackPartialDesc(
CmResourceTypeInterrupt,
irpsp->Parameters.StartDevice.AllocatedResourcesTranslated,
&Count);
if (pDesc == NULL)
{
ERRPRINT(("no allocated IRQ resources!\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
}
else
{
int i;
UCHAR Buttons;
ASSERT(!(devext->dwfHBut & HBUTF_INTERRUPT_CONNECTED));
devext->IRQRes = *pDesc;
//
// To determine potential stuck buttons, read the buttons
// up to 5 times for any button down bits without an interrupt.
//
for (i = 0; i < STUCK_DETECTION_RETRIES; ++i)
{
Buttons = READBUTTONSTATE(devext);
if (!(Buttons & BUTTON_INTERRUPT_MASK))
{
devext->StuckButtonsMask |= Buttons &
BUTTON_STATUS_MASK;
}
}
devext->StuckButtonsMask = Buttons & BUTTON_STATUS_MASK;
DBGPRINT(1, ("StuckButtonsMask=%x\n",
devext->StuckButtonsMask));
status = IoConnectInterrupt(
&devext->InterruptObject,
OemInterruptServiceRoutine,
devext,
NULL,
devext->IRQRes.u.Interrupt.Vector,
(KIRQL)devext->IRQRes.u.Interrupt.Level,
(KIRQL)devext->IRQRes.u.Interrupt.Level,
(devext->IRQRes.Flags & CM_RESOURCE_INTERRUPT_LATCHED)?
Latched: LevelSensitive,
devext->IRQRes.ShareDisposition == CmResourceShareShared,
devext->IRQRes.u.Interrupt.Affinity,
FALSE);
if (NT_SUCCESS(status))
{
devext->dwfHBut |= HBUTF_INTERRUPT_CONNECTED;
DBGPRINT(3, ("IO(Start=0x%x%x,Len=0x%x), IRQ(Level=%d,Vector=0x%x,Affinity=%d)\n",
devext->IORes.u.Port.Start.HighPart,
devext->IORes.u.Port.Start.LowPart,
devext->IORes.u.Port.Length,
devext->IRQRes.u.Interrupt.Level,
devext->IRQRes.u.Interrupt.Vector,
devext->IRQRes.u.Interrupt.Affinity));
}
}
}
}
EXIT(2, ("=%x\n", status));
return status;
} //StartDevice
/*****************************************************************************
*
* @doc INTERNAL
*
* @func VOID | RemoveDevice | FDO Remove routine
*
* @parm IN PDEVICE_OBJECT | DevObj | Points to the device object.
* @parm IN PIRP | Irp | Points to an I/O request packet.
*
*****************************************************************************/
VOID INTERNAL
RemoveDevice(
PDEVICE_OBJECT DevObj,
PIRP Irp
)
{
PROCNAME("RemoveDevice")
PDEVICE_EXTENSION devext;
PAGED_CODE();
ENTER(2, ("(DevObj=%p,Irp=%p)\n", DevObj, Irp));
devext = GET_MINIDRIVER_DEVICE_EXTENSION(DevObj);
ASSERT(devext->dwfHBut & HBUTF_DEVICE_REMOVED);
if (devext->dwfHBut & HBUTF_INTERRUPT_CONNECTED)
{
IoDisconnectInterrupt(devext->InterruptObject);
devext->dwfHBut &= ~HBUTF_INTERRUPT_CONNECTED;
}
if (devext->dwfHBut & HBUTF_DEBOUNCE_TIMER_SET)
{
KeCancelTimer(&devext->DebounceTimer);
}
#ifdef DEBUG
ExAcquireFastMutex(&gmutexDevExtList);
RemoveEntryList(&devext->List);
ExReleaseFastMutex (&gmutexDevExtList);
#endif
EXIT(2, ("!\n"));
return;
} //RemoveDevice
/*****************************************************************************
*
* @doc INTERNAL
*
* @func NTSTATUS | SendSyncIrp |
* Send an IRP synchronously down the stack.
*
* @parm IN PDEVICE_OBJECT | DevObj | Points to the device object.
* @parm IN PIRP | Irp | Points to the IRP.
* @parm IN BOOLEAN | fCopyToNext | if TRUE, copy the irpsp to next location.
*
* @rvalue SUCCESS | returns STATUS_SUCCESS
* @rvalue FAILURE | returns NT status code
*
*****************************************************************************/
NTSTATUS INTERNAL
SendSyncIrp(
IN PDEVICE_OBJECT DevObj,
IN PIRP Irp,
IN BOOLEAN fCopyToNext
)
{
PROCNAME("SendSyncIrp")
NTSTATUS status;
PIO_STACK_LOCATION irpsp = IoGetCurrentIrpStackLocation(Irp);
KEVENT event;
PAGED_CODE();
ENTER(2, ("(DevObj=%p,Irp=%p,fCopyToNext=%x,MajorFunc=%s)\n",
DevObj, Irp, fCopyToNext,
LookupName(irpsp->MajorFunction, MajorFnNames)));
KeInitializeEvent(&event, SynchronizationEvent, FALSE);
if (fCopyToNext)
{
IoCopyCurrentIrpStackLocationToNext(Irp);
}
IoSetCompletionRoutine(Irp, IrpCompletion, &event, TRUE, TRUE, TRUE);
if (irpsp->MajorFunction == IRP_MJ_POWER)
{
ENTER(2, (".PoCallDriver(DevObj=%p,Irp=%p)\n", DevObj, Irp));
status = PoCallDriver(DevObj, Irp);
EXIT(2, (".IoCallDriver=%x\n", status));
}
else
{
ENTER(2, (".IoCallDriver(DevObj=%p,Irp=%p)\n", DevObj, Irp));
status = IoCallDriver(DevObj, Irp);
EXIT(2, (".IoCallDriver=%x\n", status));
}
if (status == STATUS_PENDING)
{
status = KeWaitForSingleObject(&event,
Executive,
KernelMode,
FALSE,
NULL);
}
if (NT_SUCCESS(status))
{
status = Irp->IoStatus.Status;
}
EXIT(2, ("=%x\n", status));
return status;
} //SendSyncIrp
/*****************************************************************************
*
* @doc INTERNAL
*
* @func NTSTATUS | IrpCompletion | Completion routine for all IRPs.
*
* @parm IN PDEVICE_OBJECT | DevObj | Points to the device object.
* @parm IN PIRP | Irp | Points to an I/O request packet.
* @parm IN PKEVENT | Event | Points to the event to notify.
*
* @rvalue STATUS_MORE_PROCESSING_REQUIRED | We want the IRP back
*
*****************************************************************************/
NTSTATUS INTERNAL
IrpCompletion(
IN PDEVICE_OBJECT DevObj,
IN PIRP Irp,
IN PKEVENT Event
)
{
PROCNAME("IrpCompletion")
ENTER(2, ("(DevObj=%p,Irp=%p,Event=%p)\n", DevObj, Irp, Event));
UNREFERENCED_PARAMETER(DevObj);
KeSetEvent(Event, 0, FALSE);
/*
* If the lower driver returned PENDING, mark our stack location as
* pending also. This prevents the IRP's thread from being freed if
* the client's call returns pending.
*/
if (Irp->PendingReturned)
{
IoMarkIrpPending(Irp);
}
EXIT(2, ("=%x\n", STATUS_MORE_PROCESSING_REQUIRED));
return STATUS_MORE_PROCESSING_REQUIRED;
} //IrpCompletion