NTSTATUS
Bus_SystemControl (
__in PDEVICE_OBJECT DeviceObject,
__in PIRP Irp
)
/*++
Routine Description
We have just received a System Control IRP.
Assume that this is a WMI IRP and
call into the WMI system library and let it handle this IRP for us.
--*/
{
PFDO_DEVICE_DATA fdoData;
SYSCTL_IRP_DISPOSITION disposition;
NTSTATUS status;
PIO_STACK_LOCATION stack;
PCOMMON_DEVICE_DATA commonData;
PAGED_CODE();
KdPrint(("Bus SystemControl\r\n"));
stack = IoGetCurrentIrpStackLocation (Irp);
commonData = (PCOMMON_DEVICE_DATA) DeviceObject->DeviceExtension;
if (!commonData->IsFDO) {
//
// The PDO, just complete the request with the current status
//
Bus_KdPrint (commonData, BUS_DBG_WMI_TRACE,
("PDO %s\n", WMIMinorFunctionString(stack->MinorFunction)));
status = Irp->IoStatus.Status;
IoCompleteRequest (Irp, IO_NO_INCREMENT);
return status;
}
fdoData = (PFDO_DEVICE_DATA) DeviceObject->DeviceExtension;
Bus_KdPrint (fdoData, BUS_DBG_WMI_TRACE,
("FDO: %s\n", WMIMinorFunctionString(stack->MinorFunction)));
Bus_IncIoCount (fdoData);
if (fdoData->DevicePnPState == Deleted) {
Irp->IoStatus.Status = status = STATUS_NO_SUCH_DEVICE ;
IoCompleteRequest (Irp, IO_NO_INCREMENT);
Bus_DecIoCount (fdoData);
return status;
}
status = WmiSystemControl(&fdoData->WmiLibInfo,
DeviceObject,
Irp,
&disposition);
switch(disposition)
{
case IrpProcessed:
{
//
// This irp has been processed and may be completed or pending.
break;
}
case IrpNotCompleted:
{
//
// This irp has not been completed, but has been fully processed.
// we will complete it now
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
}
case IrpForward:
case IrpNotWmi:
{
//
// This irp is either not a WMI irp or is a WMI irp targetted
// at a device lower in the stack.
IoSkipCurrentIrpStackLocation (Irp);
status = IoCallDriver (fdoData->NextLowerDriver, Irp);
break;
}
default:
{
//
// We really should never get here, but if we do just forward....
ASSERT(FALSE);
IoSkipCurrentIrpStackLocation (Irp);
status = IoCallDriver (fdoData->NextLowerDriver, Irp);
break;
}
}
Bus_DecIoCount (fdoData);
return(status);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// testdrvDumpIrp
// Dump Irp fields to the debugger.
//
// Arguments:
// IN Irp
// Irp to display
//
// Return Value:
// None.
//
VOID testdrvDumpIrp(
IN PIRP Irp
)
{
ULONG debugArea;
PIO_STACK_LOCATION irpStack;
// Get our current IRP stack location
irpStack = IoGetCurrentIrpStackLocation(Irp);
// determine debug area
switch (irpStack->MajorFunction)
{
case IRP_MJ_PNP:
debugArea = DBG_PNP;
break;
case IRP_MJ_POWER:
debugArea = DBG_POWER;
break;
case IRP_MJ_CREATE:
case IRP_MJ_CLOSE:
case IRP_MJ_CLEANUP:
debugArea = DBG_CREATECLOSE;
break;
case IRP_MJ_SYSTEM_CONTROL:
debugArea = DBG_WMI;
break;
case IRP_MJ_READ:
case IRP_MJ_WRITE:
case IRP_MJ_DEVICE_CONTROL:
case IRP_MJ_INTERNAL_DEVICE_CONTROL:
debugArea = DBG_IO;
break;
default:
debugArea = DBG_GENERAL;
break;
}
testdrvDebugPrint(debugArea, DBG_INFO, "IRP %p %s", Irp, IrpMajorFunctionString(irpStack->MajorFunction));
if (irpStack->MajorFunction == IRP_MJ_PNP)
{
testdrvDebugPrint(debugArea, DBG_INFO, "%s", PnPMinorFunctionString(irpStack->MinorFunction));
}
else if (irpStack->MajorFunction == IRP_MJ_POWER)
{
testdrvDebugPrint(debugArea, DBG_INFO, "%s", PowerMinorFunctionString(irpStack->MinorFunction));
if (irpStack->Parameters.Power.Type == SystemPowerState)
{
testdrvDebugPrint(debugArea, DBG_INFO, "%s", SystemPowerStateString(irpStack->Parameters.Power.State.SystemState));
}
else
{
testdrvDebugPrint(debugArea, DBG_INFO, "%s", DevicePowerStateString(irpStack->Parameters.Power.State.DeviceState));
}
}
else if (irpStack->MajorFunction == IRP_MJ_SYSTEM_CONTROL)
{
testdrvDebugPrint(debugArea, DBG_INFO, "%s", WMIMinorFunctionString(irpStack->MinorFunction));
}
}
NTSTATUS NTAPI FreeBT_DispatchSysCtrl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
PDEVICE_EXTENSION deviceExtension;
SYSCTL_IRP_DISPOSITION disposition;
NTSTATUS ntStatus;
PIO_STACK_LOCATION irpStack;
PAGED_CODE();
irpStack = IoGetCurrentIrpStackLocation (Irp);
deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
FreeBT_DbgPrint(3, ("FBTUSB: "));
FreeBT_DbgPrint(3, (WMIMinorFunctionString(irpStack->MinorFunction)));
if (Removed == deviceExtension->DeviceState)
{
ntStatus = STATUS_DELETE_PENDING;
Irp->IoStatus.Status = ntStatus;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return ntStatus;
}
FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_DispatchSysCtrl::"));
FreeBT_IoIncrement(deviceExtension);
ntStatus = WmiSystemControl(&deviceExtension->WmiLibInfo,
DeviceObject,
Irp,
&disposition);
switch(disposition)
{
case IrpProcessed:
{
// This irp has been processed and may be completed or pending.
break;
}
case IrpNotCompleted:
{
// This irp has not been completed, but has been fully processed.
// we will complete it now
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
}
case IrpForward:
case IrpNotWmi:
{
// This irp is either not a WMI irp or is a WMI irp targeted
// at a device lower in the stack.
IoSkipCurrentIrpStackLocation (Irp);
ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
break;
}
default:
{
// We really should never get here, but if we do just forward....
ASSERT(FALSE);
IoSkipCurrentIrpStackLocation (Irp);
ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
break;
}
}
FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_DispatchSysCtrl::"));
FreeBT_IoDecrement(deviceExtension);
return ntStatus;
}
NTSTATUS
PciDrvSystemControl (
PDEVICE_OBJECT DeviceObject,
PIRP Irp
)
/*++
Routine Description
We have just received a System Control IRP.
Assume that this is a WMI IRP and
call into the WMI system library and let it handle this IRP for us.
--*/
{
PFDO_DATA fdoData;
SYSCTL_IRP_DISPOSITION disposition;
NTSTATUS status;
PIO_STACK_LOCATION stack;
PAGED_CODE();
stack = IoGetCurrentIrpStackLocation (Irp);
DebugPrint(TRACE, DBG_WMI, "FDO %s\n",
WMIMinorFunctionString(stack->MinorFunction));
fdoData = (PFDO_DATA) DeviceObject->DeviceExtension;
PciDrvPowerUpDevice(fdoData, TRUE);
PciDrvIoIncrement (fdoData);
if (fdoData->DevicePnPState == Deleted) {
Irp->IoStatus.Status = status = STATUS_NO_SUCH_DEVICE;
IoCompleteRequest (Irp, IO_NO_INCREMENT);
PciDrvIoDecrement (fdoData);
return status;
}
status = WmiSystemControl(&fdoData->WmiLibInfo,
DeviceObject,
Irp,
&disposition);
//
// Following code is required if we want to do tracing in WIN2K.
// Tracing is enabled or disabled explicitly by sending WMI
// control events on Win2K.
//
#if defined(WIN2K) && defined(EVENT_TRACING)
if (disposition != IrpProcessed &&
DeviceObject == (PDEVICE_OBJECT)stack->Parameters.WMI.ProviderId) {
ULONG returnSize = 0;
DebugPrint(INFO, DBG_WMI, "Calling WPP_TRACE_CONTROL\n");
WPP_TRACE_CONTROL(stack->MinorFunction,
stack->Parameters.WMI.Buffer,
stack->Parameters.WMI.BufferSize,
returnSize);
}
#endif
switch(disposition)
{
case IrpProcessed:
{
//
// This irp has been processed and may be completed or pending.
break;
}
case IrpNotCompleted:
{
//
// This irp has not been completed, but has been fully processed.
// we will complete it now
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
}
case IrpForward:
case IrpNotWmi:
{
//
// This irp is either not a WMI irp or is a WMI irp targeted
// at a device lower in the stack.
IoSkipCurrentIrpStackLocation (Irp);
status = IoCallDriver (fdoData->NextLowerDriver, Irp);
break;
}
default:
{
//
// We really should never get here, but if we do just forward....
ASSERT(FALSE);
IoSkipCurrentIrpStackLocation (Irp);
status = IoCallDriver (fdoData->NextLowerDriver, Irp);
break;
}
}
PciDrvIoDecrement(fdoData);
return(status);
}