reactos/modules/rosapps/drivers/vfd/vfdpnp.c

/*
	vfdpnp.c

	Virtual Floppy Drive for Windows NT platform
	Kernel mode driver: Plug & Play functions

	Copyright (C) 2003-2005 Ken Kato
*/

#ifndef VFD_PNP
/*
	Not in working order for the time being
	so DO NOT define VFD_PNP macro
	unless you know exactly what you are doing...
*/
//	suppress empty compile unit warning
#ifdef _MSC_VER
#pragma warning (disable: 4206)
#pragma message ("Plug and play support feature is disabled.")
#endif

#else	// VFD_PNP

#include "imports.h"
#include "vfddrv.h"
#include "vfddbg.h"

static NTSTATUS
VfdReportDevice(
	PDEVICE_EXTENSION	device_extension);

#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, VfdPlugAndPlay)
#pragma alloc_text(PAGE, VfdPowerControl)
#pragma alloc_text(PAGE, VfdSystemControl)
#pragma alloc_text(PAGE, VfdAddDevice)
#pragma alloc_text(PAGE, VfdReportDevice)
#endif	// ALLOC_PRAGMA

#define REMLOCK_TAG				'LdfV'	//	"VfdL"
#define REMLOCK_MAXIMUM			1		//	Max minutes system allows lock to be held
#define REMLOCK_HIGHWATER		10		//	Max number of irps holding lock at one time

#if DBG
static PCSTR StateTable[] ={
	{ "STOPPED"		},
	{ "WORKING"		},
	{ "PENDINGSTOP"	},
	{ "PENDINGREMOVE"	},
	{ "SURPRISEREMOVED" },
	{ "REMOVED"		},
	{ "UNKNOWN"		}
};
#endif	// DBG

//
//	PnP I/O request dispatch
//
NTSTATUS
VfdPlugAndPlay(
	IN PDEVICE_OBJECT		DeviceObject,
	IN PIRP					Irp)
{
	PIO_STACK_LOCATION		io_stack;
	PDEVICE_EXTENSION		device_extension;
	NTSTATUS				status = STATUS_SUCCESS;
	BOOLEAN				lockHeld = TRUE;

	//
	//	setup necessary pointers
	//
	io_stack			= IoGetCurrentIrpStackLocation( Irp );
	device_extension	= (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;

	ASSERT(device_extension->DeviceState < VFD_MAX_STATE);

	VFDTRACE(VFDINFO, ("[VFD] VfdPlugAndPlay - IN. %ws %s Device State=%s\n",
		device_extension->device_name.Buffer,
		GetPnpIrpName(io_stack->MinorFunction),
		StateTable[device_extension->DeviceState]));

	//
	//	Acquire remove lock
	//
	status = IoAcquireRemoveLock(&device_extension->RemoveLock, Irp);

	if (!NT_SUCCESS(status)) {
		VFDTRACE(0, ("Acquire RemoveLock failed - %s\n", NtStatusToStr(status)));

		Irp->IoStatus.Status = status;
		Irp->IoStatus.Information = 0;
		IoCompleteRequest(Irp, IO_NO_INCREMENT);
		return status;
	}

	//
	//	Process the PnP I/O request
	//
	switch (io_stack->MinorFunction) {
	case IRP_MN_START_DEVICE:					// 0x00
		//
		//	Start the device
		//
		device_extension->DeviceState = VFD_WORKING;
		status = STATUS_SUCCESS;

		Irp->IoStatus.Status = status;
		Irp->IoStatus.Information = 0;
		IoCompleteRequest(Irp, IO_NO_INCREMENT);
		break;

	case IRP_MN_QUERY_REMOVE_DEVICE:					// 0x01
		//
		//	Prepare device removal
		//
		device_extension->DeviceState = VFD_PENDINGREMOVE;
		status = STATUS_SUCCESS;

		Irp->IoStatus.Status = status;
		Irp->IoStatus.Information = 0;
		IoCompleteRequest(Irp, IO_NO_INCREMENT);
		break;

	case IRP_MN_REMOVE_DEVICE:							// 0x02
		//
		//	Remove the device
		//
		status = STATUS_SUCCESS;

		//	complete the current request
		Irp->IoStatus.Status = status;
		Irp->IoStatus.Information = 0;
		IoCompleteRequest(Irp, IO_NO_INCREMENT);

		//
		// Set the device status to REMOVED and wait for other drivers
		// to release the lock, then delete the device object
		//
		device_extension->DeviceState = VFD_REMOVED;
		IoReleaseRemoveLockAndWait(&device_extension->RemoveLock, Irp);
		lockHeld = FALSE;

		VfdRemoveDevice(DeviceObject);
		break;

	case IRP_MN_CANCEL_REMOVE_DEVICE:					// 0x03
		//
		// Before sending the IRP down make sure we have received
		// a IRP_MN_QUERY_REMOVE_DEVICE. We may get Cancel Remove
		// without receiving a Query Remove earlier, if the
		// driver on top fails a Query Remove and passes down the
		// Cancel Remove.
		//

		if (device_extension->DeviceState == VFD_PENDINGREMOVE) {
			device_extension->DeviceState = VFD_WORKING;
		}

		status = STATUS_SUCCESS;
		Irp->IoStatus.Status = status;
		Irp->IoStatus.Information = 0;
		IoCompleteRequest(Irp, IO_NO_INCREMENT);

		break;

	case IRP_MN_STOP_DEVICE:							// 0x04
		device_extension->DeviceState = VFD_STOPPED;

		status = STATUS_SUCCESS;
		Irp->IoStatus.Status = status;
		Irp->IoStatus.Information = 0;
		IoCompleteRequest(Irp, IO_NO_INCREMENT);
		break;

	case IRP_MN_QUERY_STOP_DEVICE:						// 0x05
		device_extension->DeviceState = VFD_PENDINGSTOP;

		status = STATUS_SUCCESS;
		Irp->IoStatus.Status = status;
		Irp->IoStatus.Information = 0;
		IoCompleteRequest(Irp, IO_NO_INCREMENT);
		break;

	case IRP_MN_CANCEL_STOP_DEVICE:						// 0x06
		//
		// Before sending the IRP down make sure we have received
		// a IRP_MN_QUERY_STOP_DEVICE. We may get Cancel Stop
		// without receiving a Query Stop earlier, if the
		// driver on top fails a Query Stop and passes down the
		// Cancel Stop.
		//

		if (device_extension->DeviceState == VFD_PENDINGSTOP ) {
			device_extension->DeviceState = VFD_WORKING;
		}

		status = STATUS_SUCCESS;
		Irp->IoStatus.Status = status;
		Irp->IoStatus.Information = 0;
		IoCompleteRequest(Irp, IO_NO_INCREMENT);
		break;

	case IRP_MN_QUERY_DEVICE_RELATIONS:				// 0x07
		status = STATUS_SUCCESS;
		Irp->IoStatus.Information = 0;

		switch (io_stack->Parameters.QueryDeviceRelations.Type) {
		case BusRelations:
			VFDTRACE(VFDINFO, ("------- BusRelations Query\n"));
			break;

		case EjectionRelations:
			VFDTRACE(VFDINFO, ("------- EjectionRelations Query\n"));
			break;

		case PowerRelations:
			VFDTRACE(VFDINFO, ("------- PowerRelations Query\n"));
			break;

		case RemovalRelations:
			VFDTRACE(VFDINFO, ("------- RemovalRelations Query\n"));
			break;

		case TargetDeviceRelation:
			VFDTRACE(VFDINFO, ("------- TargetDeviceRelation Query\n"));

			Irp->IoStatus.Information = (LONG)ExAllocatePoolWithTag(
				PagedPool, sizeof(DEVICE_RELATIONS), VFD_POOL_TAG);

			if (Irp->IoStatus.Information) {
				PDEVICE_RELATIONS rel = (PDEVICE_RELATIONS)Irp->IoStatus.Information;

				rel->Count = 1;
				rel->Objects[0] = device_extension->device_object;

				status = STATUS_SUCCESS;
			}
			else {
				status = STATUS_INSUFFICIENT_RESOURCES;
			}
			break;

		default:
			VFDTRACE(VFDINFO, ("------- Unknown Query\n"));
			break;
		}
		Irp->IoStatus.Status = status;
		IoCompleteRequest(Irp, IO_NO_INCREMENT);

		break;

//	case IRP_MN_QUERY_INTERFACE:						// 0x08
//	case IRP_MN_QUERY_CAPABILITIES:					// 0x09
//	case IRP_MN_QUERY_RESOURCES:						// 0x0A
//	case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:			// 0x0B
//	case IRP_MN_QUERY_DEVICE_TEXT:						// 0x0C
//	case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:			// 0x0D
//	case IRP_MN_READ_CONFIG:							// 0x0F
//	case IRP_MN_WRITE_CONFIG:							// 0x10
//	case IRP_MN_EJECT:									// 0x11
//	case IRP_MN_SET_LOCK:								// 0x12
//	case IRP_MN_QUERY_ID:								// 0x13
//	case IRP_MN_QUERY_PNP_DEVICE_STATE:				// 0x14
//	case IRP_MN_QUERY_BUS_INFORMATION:					// 0x15
//	case IRP_MN_DEVICE_USAGE_NOTIFICATION:				// 0x16

	case IRP_MN_SURPRISE_REMOVAL:						// 0x17
		device_extension->DeviceState = VFD_SURPRISEREMOVED;

		status = STATUS_SUCCESS;
		Irp->IoStatus.Status = status;
		Irp->IoStatus.Information = 0;
		IoCompleteRequest(Irp, IO_NO_INCREMENT);
		break;

//	case IRP_MN_QUERY_LEGACY_BUS_INFORMATION:			// 0x18

	default:
		//
		//	unknown request -- simply pass it to the lower device
		//
		status = STATUS_INVALID_DEVICE_REQUEST;
		Irp->IoStatus.Status = status;
		Irp->IoStatus.Information = 0;
		IoCompleteRequest(Irp, IO_NO_INCREMENT);
		break;
	}

	//
	// Device Extenion is gone if the current IRP is IRP_MN_REMOVE_DEVICE
	//
	if (lockHeld == TRUE) {
		IoReleaseRemoveLock(&device_extension->RemoveLock, Irp);
	}

	VFDTRACE(VFDINFO, ("[VFD] VfdPlugAndPlay - %s\n", NtStatusToStr(status)));

	return status;
}

//
//	Power management I/O request dispatch
//
NTSTATUS
VfdPowerControl(
	IN PDEVICE_OBJECT		DeviceObject,
	IN PIRP				Irp)
{
	PIO_STACK_LOCATION		io_stack;
	PDEVICE_EXTENSION		device_extension;
	NTSTATUS				status;

	io_stack = IoGetCurrentIrpStackLocation( Irp );
	device_extension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;

	VFDTRACE(VFDINFO, ("[VFD] VfdPowerControl - IN. %ws %s Device State=%s\n",
		device_extension->device_name.Buffer,
		GetPnpIrpName(io_stack->MinorFunction),
		StateTable[device_extension->DeviceState]));

	PoStartNextPowerIrp(Irp);

	//
	// If the device has been removed, the driver should not pass
	// the IRP down to the next lower driver.
	//

	if (device_extension->DeviceState == VFD_REMOVED) {
		status = STATUS_DELETE_PENDING;
	}
	else {
		status = STATUS_SUCCESS;
	}

	Irp->IoStatus.Status = status;
	Irp->IoStatus.Information = 0;
	IoCompleteRequest(Irp, IO_NO_INCREMENT);

	VFDTRACE(VFDINFO, ("[VFD] VfdPowerControl - %s\n", NtStatusToStr(status)));

	return status;
}

//
//	WMI I/O request dispatch
//
NTSTATUS
VfdSystemControl(
	IN PDEVICE_OBJECT		DeviceObject,
	IN PIRP				Irp)
{
	PIO_STACK_LOCATION		io_stack;
	PDEVICE_EXTENSION		device_extension;
	NTSTATUS				status;

	io_stack = IoGetCurrentIrpStackLocation(Irp);
	device_extension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;

	VFDTRACE(VFDINFO, ("[VFD] VfdSystemControl - IN. %ws %s Device State=%s\n",
		device_extension->device_name.Buffer,
		GetPnpIrpName(io_stack->MinorFunction),
		StateTable[device_extension->DeviceState]));

	status = STATUS_SUCCESS;
	Irp->IoStatus.Status = status;
	Irp->IoStatus.Information = 0;
	IoCompleteRequest(Irp, IO_NO_INCREMENT);

	VFDTRACE(VFDINFO, ("[VFD] VfdSystemControl - %s\n", NtStatusToStr(status)));

	return status;
}

//
//	PnP AddDevice function
//
NTSTATUS
VfdAddDevice(
	IN		PDRIVER_OBJECT		DriverObject,
	IN OUT	PDEVICE_OBJECT		PhysicalDevice)
{
	PDEVICE_OBJECT		device_object;
	PDEVICE_EXTENSION	device_extension;
	NTSTATUS status;

	VFDTRACE(VFDINFO, ("[VFD] VfdAddDevice - IN\n"));

	status = VfdCreateDevice(DriverObject, &device_object);

	if (NT_SUCCESS(status)) {

		device_object->Flags |= DO_POWER_PAGABLE;

		device_extension =
			(PDEVICE_EXTENSION)device_object->DeviceExtension;

		// Device starts in Stopped state
		device_extension->DeviceState = VFD_STOPPED;

		VFDTRACE(VFDINFO, ("[VFD] Initializing the remove lock\n"));

		IoInitializeRemoveLock(
			&device_extension->RemoveLock,
			REMLOCK_TAG,
			REMLOCK_MAXIMUM,
			REMLOCK_HIGHWATER);

		if (PhysicalDevice) {
			device_extension->PhysicalDevice = PhysicalDevice;
		}
		else {
			VfdReportDevice(device_extension);
		}
		VfdRegisterInterface(device_extension);
		VfdMountMgrNotifyVolume(device_extension);
	}

	return status;
}

//
//	Report a VFD device to the PnP manager
//
NTSTATUS
VfdReportDevice(
	PDEVICE_EXTENSION	device_extension)
{
	NTSTATUS status	= STATUS_SUCCESS;
	CM_RESOURCE_LIST				list = {0};
	PCM_FULL_RESOURCE_DESCRIPTOR	full = &(list.List[0]);
	PCM_PARTIAL_RESOURCE_LIST		part = &(full->PartialResourceList);
	PCM_PARTIAL_RESOURCE_DESCRIPTOR	desc = &(part->PartialDescriptors[0]);;

	list.Count				= 1;

	full->InterfaceType		= Internal;
	full->BusNumber		= device_extension->device_number;

	part->Version			= 1;
	part->Revision			= 1;
	part->Count			= 1;

	desc->Type				= CmResourceTypeDeviceSpecific;
	desc->ShareDisposition	= CmResourceShareShared;
	desc->Flags			= 0;

	VFDTRACE(VFDINFO,("[VFD] Reporting device %lu to the PnP manager\n",
		device_extension->device_number));

	status = IoReportDetectedDevice(
		device_extension->device_object->DriverObject,	// IN PDRIVER_OBJECT DriverObject,
		Internal,								// IN INTERFACE_TYPE LegacyBusType,
		(ULONG)-1,								// IN ULONG BusNumber,
		(ULONG)-1,								// IN ULONG SlotNumber,
		&list,									// IN PCM_RESOURCE_LIST ResourceList,
		NULL,									// IN PIO_RESOURCE_REQUIREMENTS_LIST OPTIONAL,
		TRUE,									// IN BOOLEAN ResourceAssigned,
		&(device_extension->PhysicalDevice)		// IN OUT PDEVICE_OBJECT *DeviceObject
	);

	if (!NT_SUCCESS(status)) {
		VFDTRACE(0,
			("[VFD] IoReportDetectedDevice - %s\n",
			NtStatusToStr(status)));
	}

	device_extension->TargetDevice = IoAttachDeviceToDeviceStack(
		device_extension->device_object,
		device_extension->PhysicalDevice);

	return status;
}

#endif	// VFD_PNP