895 lines
24 KiB
C
895 lines
24 KiB
C
/*++
|
||
|
||
Copyright (c) 1991-1998 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
pnp.c
|
||
|
||
Abstract:
|
||
|
||
Author:
|
||
|
||
Neil Sandlin (neilsa) 26-Apr-99
|
||
|
||
Environment:
|
||
|
||
Kernel mode only.
|
||
|
||
--*/
|
||
#include "pch.h"
|
||
|
||
//
|
||
// Internal References
|
||
//
|
||
|
||
NTSTATUS
|
||
MemCardStartDevice(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
NTSTATUS
|
||
MemCardGetResourceRequirements(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
NTSTATUS
|
||
MemCardPnpComplete (
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN PVOID Context
|
||
);
|
||
|
||
NTSTATUS
|
||
MemCardGetDeviceParameters(
|
||
IN PMEMCARD_EXTENSION memcardExtension
|
||
);
|
||
|
||
|
||
#ifdef ALLOC_PRAGMA
|
||
#pragma alloc_text(PAGE,MemCardAddDevice)
|
||
#pragma alloc_text(PAGE,MemCardPnp)
|
||
#pragma alloc_text(PAGE,MemCardStartDevice)
|
||
#endif
|
||
|
||
|
||
#define MEMCARD_DEVICE_NAME L"\\Device\\Memcard"
|
||
#define MEMCARD_LINK_NAME L"\\DosDevices\\Memcard"
|
||
#define MEMCARD_REGISTRY_NODRIVE_KEY L"NoDrive"
|
||
#define MEMCARD_REGISTRY_MTD_KEY L"Mtd"
|
||
|
||
|
||
|
||
NTSTATUS
|
||
MemCardAddDevice(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN OUT PDEVICE_OBJECT PhysicalDeviceObject
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is the driver's pnp add device entry point. It is
|
||
called by the pnp manager to initialize the driver.
|
||
|
||
Add device creates and initializes a device object for this FDO and
|
||
attaches to the underlying PDO.
|
||
|
||
Arguments:
|
||
|
||
DriverObject - a pointer to the object that represents this device driver.
|
||
PhysicalDeviceObject - a pointer to the underlying PDO to which this new device will attach.
|
||
|
||
Return Value:
|
||
|
||
If we successfully create a device object, STATUS_SUCCESS is
|
||
returned. Otherwise, return the appropriate error code.
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS status = STATUS_SUCCESS;
|
||
PDEVICE_OBJECT deviceObject;
|
||
PMEMCARD_EXTENSION memcardExtension;
|
||
WCHAR NameBuffer[128];
|
||
UNICODE_STRING deviceName;
|
||
UNICODE_STRING linkName;
|
||
LONG deviceNumber = -1;
|
||
KEVENT event;
|
||
PIRP irp;
|
||
IO_STATUS_BLOCK statusBlock;
|
||
PIO_STACK_LOCATION irpSp;
|
||
|
||
MemCardDump(MEMCARDSHOW, ("MemCard: AddDevice...\n"));
|
||
|
||
//
|
||
// Create a device. We will use the first available device name for
|
||
// this device.
|
||
//
|
||
do {
|
||
|
||
swprintf(NameBuffer, L"%s%d", MEMCARD_DEVICE_NAME, ++deviceNumber);
|
||
RtlInitUnicodeString(&deviceName, NameBuffer);
|
||
status = IoCreateDevice(DriverObject,
|
||
sizeof(MEMCARD_EXTENSION),
|
||
&deviceName,
|
||
FILE_DEVICE_DISK,
|
||
FILE_REMOVABLE_MEDIA,
|
||
FALSE,
|
||
&deviceObject);
|
||
|
||
} while (status == STATUS_OBJECT_NAME_COLLISION);
|
||
|
||
if (!NT_SUCCESS(status)) {
|
||
return status;
|
||
}
|
||
|
||
memcardExtension = (PMEMCARD_EXTENSION)deviceObject->DeviceExtension;
|
||
RtlZeroMemory(memcardExtension, sizeof(MEMCARD_EXTENSION));
|
||
|
||
memcardExtension->DeviceObject = deviceObject;
|
||
|
||
//
|
||
// Save the device name.
|
||
//
|
||
MemCardDump(MEMCARDSHOW | MEMCARDPNP,
|
||
("MemCard: AddDevice - Device Object Name - %S\n", NameBuffer));
|
||
|
||
memcardExtension->DeviceName.Buffer = ExAllocatePool(PagedPool, deviceName.Length);
|
||
if (memcardExtension->DeviceName.Buffer == NULL) {
|
||
status = STATUS_INSUFFICIENT_RESOURCES;
|
||
goto errorExit;
|
||
}
|
||
memcardExtension->DeviceName.Length = 0;
|
||
memcardExtension->DeviceName.MaximumLength = deviceName.Length;
|
||
RtlCopyUnicodeString(&memcardExtension->DeviceName, &deviceName);
|
||
|
||
//
|
||
// create the link name
|
||
//
|
||
|
||
swprintf(NameBuffer, L"%s%d", MEMCARD_LINK_NAME, deviceNumber);
|
||
RtlInitUnicodeString(&linkName, NameBuffer);
|
||
|
||
memcardExtension->LinkName.Buffer = ExAllocatePool(PagedPool, linkName.Length);
|
||
if (memcardExtension->LinkName.Buffer == NULL) {
|
||
status = STATUS_INSUFFICIENT_RESOURCES;
|
||
goto errorExit;
|
||
}
|
||
memcardExtension->LinkName.Length = 0;
|
||
memcardExtension->LinkName.MaximumLength = linkName.Length;
|
||
RtlCopyUnicodeString(&memcardExtension->LinkName, &linkName);
|
||
|
||
status = IoCreateSymbolicLink(&memcardExtension->LinkName, &memcardExtension->DeviceName);
|
||
|
||
if (!NT_SUCCESS(status)) {
|
||
goto errorExit;
|
||
}
|
||
|
||
//
|
||
// Set the PDO for use with PlugPlay functions
|
||
//
|
||
|
||
memcardExtension->UnderlyingPDO = PhysicalDeviceObject;
|
||
|
||
MemCardDump(MEMCARDSHOW, ("MemCard: AddDevice attaching %p to %p\n", deviceObject, PhysicalDeviceObject));
|
||
|
||
memcardExtension->TargetObject = IoAttachDeviceToDeviceStack(deviceObject, PhysicalDeviceObject);
|
||
|
||
MemCardDump(MEMCARDSHOW,
|
||
("MemCard: AddDevice TargetObject = %p\n",
|
||
memcardExtension->TargetObject));
|
||
|
||
|
||
//
|
||
// Get pcmcia interfaces
|
||
//
|
||
KeInitializeEvent(&event, NotificationEvent, FALSE);
|
||
irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP, memcardExtension->UnderlyingPDO,
|
||
NULL, 0, 0, &event, &statusBlock);
|
||
|
||
if (!irp) {
|
||
status = STATUS_INSUFFICIENT_RESOURCES;
|
||
goto errorExit;
|
||
}
|
||
|
||
irp->IoStatus.Status = STATUS_NOT_SUPPORTED ;
|
||
irp->IoStatus.Information = 0;
|
||
|
||
irpSp = IoGetNextIrpStackLocation(irp);
|
||
|
||
irpSp->MinorFunction = IRP_MN_QUERY_INTERFACE;
|
||
|
||
irpSp->Parameters.QueryInterface.InterfaceType= &GUID_PCMCIA_INTERFACE_STANDARD;
|
||
irpSp->Parameters.QueryInterface.Size = sizeof(PCMCIA_INTERFACE_STANDARD);
|
||
irpSp->Parameters.QueryInterface.Version = 1;
|
||
irpSp->Parameters.QueryInterface.Interface = (PINTERFACE) &memcardExtension->PcmciaInterface;
|
||
|
||
status = IoCallDriver(memcardExtension->UnderlyingPDO, irp);
|
||
|
||
if (status == STATUS_PENDING) {
|
||
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
|
||
status = statusBlock.Status;
|
||
}
|
||
|
||
if (!NT_SUCCESS(status)) {
|
||
goto errorExit;
|
||
}
|
||
|
||
KeInitializeEvent(&event, NotificationEvent, FALSE);
|
||
irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP, memcardExtension->UnderlyingPDO,
|
||
NULL, 0, 0, &event, &statusBlock);
|
||
|
||
if (!irp) {
|
||
status = STATUS_INSUFFICIENT_RESOURCES;
|
||
goto errorExit;
|
||
}
|
||
|
||
irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
|
||
irp->IoStatus.Information = 0;
|
||
|
||
irpSp = IoGetNextIrpStackLocation(irp);
|
||
|
||
irpSp->MinorFunction = IRP_MN_QUERY_INTERFACE;
|
||
|
||
irpSp->Parameters.QueryInterface.InterfaceType= &GUID_PCMCIA_BUS_INTERFACE_STANDARD;
|
||
irpSp->Parameters.QueryInterface.Size = sizeof(PCMCIA_BUS_INTERFACE_STANDARD);
|
||
irpSp->Parameters.QueryInterface.Version = 1;
|
||
irpSp->Parameters.QueryInterface.Interface = (PINTERFACE) &memcardExtension->PcmciaBusInterface;
|
||
|
||
status = IoCallDriver(memcardExtension->UnderlyingPDO, irp);
|
||
|
||
if (status == STATUS_PENDING) {
|
||
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
|
||
status = statusBlock.Status;
|
||
}
|
||
|
||
if (!NT_SUCCESS(status)) {
|
||
goto errorExit;
|
||
}
|
||
|
||
status = MemCardGetDeviceParameters(memcardExtension);
|
||
if (!NT_SUCCESS(status)) {
|
||
goto errorExit;
|
||
}
|
||
|
||
//
|
||
// done
|
||
//
|
||
|
||
deviceObject->Flags |= DO_DIRECT_IO | DO_POWER_PAGABLE;
|
||
deviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
|
||
|
||
memcardExtension->IsStarted = FALSE;
|
||
memcardExtension->IsRemoved = FALSE;
|
||
|
||
return STATUS_SUCCESS;
|
||
|
||
errorExit:
|
||
|
||
if (memcardExtension->DeviceName.Buffer != NULL) {
|
||
ExFreePool(memcardExtension->DeviceName.Buffer);
|
||
}
|
||
|
||
if (memcardExtension->LinkName.Buffer != NULL) {
|
||
IoDeleteSymbolicLink(&memcardExtension->LinkName);
|
||
ExFreePool(memcardExtension->LinkName.Buffer);
|
||
}
|
||
|
||
if (memcardExtension->TargetObject) {
|
||
IoDetachDevice(memcardExtension->TargetObject);
|
||
}
|
||
|
||
IoDeleteDevice(deviceObject);
|
||
return status;
|
||
}
|
||
|
||
|
||
|
||
NTSTATUS
|
||
MemCardPnp(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Main PNP irp dispatch routine
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - a pointer to the object that represents the device
|
||
that I/O is to be done on.
|
||
|
||
Irp - a pointer to the I/O Request Packet for this request.
|
||
|
||
Return Value:
|
||
|
||
status
|
||
|
||
--*/
|
||
{
|
||
PIO_STACK_LOCATION irpSp;
|
||
PMEMCARD_EXTENSION memcardExtension;
|
||
NTSTATUS status = STATUS_SUCCESS;
|
||
ULONG i;
|
||
|
||
|
||
memcardExtension = DeviceObject->DeviceExtension;
|
||
|
||
irpSp = IoGetCurrentIrpStackLocation(Irp);
|
||
|
||
MemCardDump(MEMCARDPNP, ("MemCard: DO %.8x Irp %.8x PNP func %x\n",
|
||
DeviceObject, Irp, irpSp->MinorFunction));
|
||
|
||
if (memcardExtension->IsRemoved) {
|
||
|
||
//
|
||
// Since the device is stopped, but we don't hold IRPs,
|
||
// this is a surprise removal. Just fail it.
|
||
//
|
||
Irp->IoStatus.Information = 0;
|
||
Irp->IoStatus.Status = STATUS_DELETE_PENDING;
|
||
IoCompleteRequest (Irp, IO_NO_INCREMENT);
|
||
return STATUS_DELETE_PENDING;
|
||
}
|
||
|
||
switch (irpSp->MinorFunction) {
|
||
|
||
case IRP_MN_START_DEVICE:
|
||
|
||
status = MemCardStartDevice(DeviceObject, Irp);
|
||
break;
|
||
|
||
case IRP_MN_QUERY_STOP_DEVICE:
|
||
case IRP_MN_QUERY_REMOVE_DEVICE:
|
||
|
||
if (irpSp->MinorFunction == IRP_MN_QUERY_STOP_DEVICE) {
|
||
MemCardDump(MEMCARDPNP,("MemCard: IRP_MN_QUERY_STOP_DEVICE\n"));
|
||
} else {
|
||
MemCardDump(MEMCARDPNP,("MemCard: IRP_MN_QUERY_REMOVE_DEVICE\n"));
|
||
}
|
||
|
||
if (!memcardExtension->IsStarted) {
|
||
//
|
||
// If we aren't started, we'll just pass the irp down.
|
||
//
|
||
IoSkipCurrentIrpStackLocation (Irp);
|
||
status = IoCallDriver(memcardExtension->TargetObject, Irp);
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
Irp->IoStatus.Status = STATUS_SUCCESS;
|
||
IoSkipCurrentIrpStackLocation(Irp);
|
||
status = IoCallDriver(memcardExtension->TargetObject, Irp);
|
||
|
||
break;
|
||
|
||
case IRP_MN_CANCEL_STOP_DEVICE:
|
||
case IRP_MN_CANCEL_REMOVE_DEVICE:
|
||
|
||
if (irpSp->MinorFunction == IRP_MN_CANCEL_STOP_DEVICE) {
|
||
MemCardDump(MEMCARDPNP,("MemCard: IRP_MN_CANCEL_STOP_DEVICE\n"));
|
||
} else {
|
||
MemCardDump(MEMCARDPNP,("MemCard: IRP_MN_CANCEL_REMOVE_DEVICE\n"));
|
||
}
|
||
|
||
if (!memcardExtension->IsStarted) {
|
||
|
||
//
|
||
// Nothing to do, just pass the irp down:
|
||
// no need to start the device
|
||
//
|
||
IoSkipCurrentIrpStackLocation (Irp);
|
||
status = IoCallDriver(memcardExtension->TargetObject, Irp);
|
||
|
||
} else {
|
||
|
||
KEVENT doneEvent;
|
||
|
||
//
|
||
// Set the status to STATUS_SUCCESS
|
||
//
|
||
Irp->IoStatus.Status = STATUS_SUCCESS;
|
||
|
||
//
|
||
// We need to wait for the lower drivers to do their job.
|
||
//
|
||
IoCopyCurrentIrpStackLocationToNext (Irp);
|
||
|
||
//
|
||
// Clear the event: it will be set in the completion
|
||
// routine.
|
||
//
|
||
KeInitializeEvent(&doneEvent,
|
||
SynchronizationEvent,
|
||
FALSE);
|
||
|
||
IoSetCompletionRoutine(Irp,
|
||
MemCardPnpComplete,
|
||
&doneEvent,
|
||
TRUE, TRUE, TRUE);
|
||
|
||
status = IoCallDriver(memcardExtension->TargetObject, Irp);
|
||
|
||
if (status == STATUS_PENDING) {
|
||
|
||
KeWaitForSingleObject(&doneEvent,
|
||
Executive,
|
||
KernelMode,
|
||
FALSE,
|
||
NULL);
|
||
|
||
status = Irp->IoStatus.Status;
|
||
}
|
||
|
||
//
|
||
// We must now complete the IRP, since we stopped it in the
|
||
// completetion routine with MORE_PROCESSING_REQUIRED.
|
||
//
|
||
Irp->IoStatus.Status = status;
|
||
Irp->IoStatus.Information = 0;
|
||
IoCompleteRequest (Irp, IO_NO_INCREMENT);
|
||
}
|
||
break;
|
||
|
||
case IRP_MN_STOP_DEVICE:
|
||
|
||
MemCardDump(MEMCARDPNP,("MemCard: IRP_MN_STOP_DEVICE\n"));
|
||
|
||
if (memcardExtension->IsMemoryMapped) {
|
||
MmUnmapIoSpace(memcardExtension->MemoryWindowBase, memcardExtension->MemoryWindowSize);
|
||
memcardExtension->MemoryWindowBase = 0;
|
||
memcardExtension->MemoryWindowSize = 0;
|
||
memcardExtension->IsMemoryMapped = FALSE;
|
||
}
|
||
|
||
memcardExtension->IsStarted = FALSE;
|
||
|
||
Irp->IoStatus.Status = STATUS_SUCCESS;
|
||
IoSkipCurrentIrpStackLocation(Irp);
|
||
status = IoCallDriver(memcardExtension->TargetObject, Irp);
|
||
|
||
break;
|
||
|
||
case IRP_MN_REMOVE_DEVICE:
|
||
|
||
MemCardDump(MEMCARDPNP,("MemCard: IRP_MN_REMOVE_DEVICE\n"));
|
||
|
||
//
|
||
// We need to mark the fact that we don't hold requests first, since
|
||
// we asserted earlier that we are holding requests only if
|
||
// we're not removed.
|
||
//
|
||
memcardExtension->IsStarted = FALSE;
|
||
memcardExtension->IsRemoved = TRUE;
|
||
|
||
//
|
||
// Forward this Irp to the underlying PDO
|
||
//
|
||
IoSkipCurrentIrpStackLocation(Irp);
|
||
Irp->IoStatus.Status = STATUS_SUCCESS;
|
||
status = IoCallDriver(memcardExtension->TargetObject, Irp);
|
||
|
||
//
|
||
// Send notification that we are going away.
|
||
//
|
||
if (memcardExtension->InterfaceString.Buffer != NULL) {
|
||
|
||
IoSetDeviceInterfaceState(&memcardExtension->InterfaceString,
|
||
FALSE);
|
||
|
||
RtlFreeUnicodeString(&memcardExtension->InterfaceString);
|
||
RtlInitUnicodeString(&memcardExtension->InterfaceString, NULL);
|
||
}
|
||
|
||
//
|
||
// Remove our link
|
||
//
|
||
IoDeleteSymbolicLink(&memcardExtension->LinkName);
|
||
|
||
RtlFreeUnicodeString(&memcardExtension->LinkName);
|
||
RtlInitUnicodeString(&memcardExtension->LinkName, NULL);
|
||
|
||
RtlFreeUnicodeString(&memcardExtension->DeviceName);
|
||
RtlInitUnicodeString(&memcardExtension->DeviceName, NULL);
|
||
|
||
//
|
||
// Detatch from the undelying device.
|
||
//
|
||
IoDetachDevice(memcardExtension->TargetObject);
|
||
|
||
//
|
||
// And delete the device.
|
||
//
|
||
IoDeleteDevice(DeviceObject);
|
||
|
||
break;
|
||
|
||
|
||
case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
|
||
status = MemCardGetResourceRequirements(DeviceObject, Irp);
|
||
break;
|
||
|
||
|
||
default:
|
||
MemCardDump(MEMCARDPNP, ("MemCardPnp: Unsupported PNP Request %x - Irp: %p\n",irpSp->MinorFunction, Irp));
|
||
IoSkipCurrentIrpStackLocation(Irp);
|
||
status = IoCallDriver(memcardExtension->TargetObject, Irp);
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
|
||
NTSTATUS
|
||
MemCardStartDevice(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Start device routine
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - a pointer to the object that represents the device
|
||
that I/O is to be done on.
|
||
|
||
Irp - a pointer to the I/O Request Packet for this request.
|
||
|
||
Return Value:
|
||
|
||
status
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS status;
|
||
NTSTATUS pnpStatus;
|
||
KEVENT doneEvent;
|
||
PCM_RESOURCE_LIST ResourceList;
|
||
PCM_RESOURCE_LIST TranslatedResourceList;
|
||
PCM_PARTIAL_RESOURCE_LIST partialResourceList, partialTranslatedList;
|
||
PCM_PARTIAL_RESOURCE_DESCRIPTOR partialResourceDesc, partialTranslatedDesc;
|
||
PCM_FULL_RESOURCE_DESCRIPTOR fullResourceDesc, fullTranslatedDesc;
|
||
|
||
PMEMCARD_EXTENSION memcardExtension = (PMEMCARD_EXTENSION)DeviceObject->DeviceExtension;
|
||
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
|
||
|
||
MemCardDump(MEMCARDPNP,("MemCard: StartDevice\n"));
|
||
MemCardDump(MEMCARDSHOW, (" AllocatedResources = %08x\n",irpSp->Parameters.StartDevice.AllocatedResources));
|
||
MemCardDump(MEMCARDSHOW, (" AllocatedResourcesTranslated = %08x\n",irpSp->Parameters.StartDevice.AllocatedResourcesTranslated));
|
||
|
||
//
|
||
// First we must pass this Irp on to the PDO.
|
||
//
|
||
KeInitializeEvent(&doneEvent, NotificationEvent, FALSE);
|
||
|
||
IoCopyCurrentIrpStackLocationToNext(Irp);
|
||
|
||
IoSetCompletionRoutine(Irp,
|
||
MemCardPnpComplete,
|
||
&doneEvent,
|
||
TRUE, TRUE, TRUE);
|
||
|
||
status = IoCallDriver(memcardExtension->TargetObject, Irp);
|
||
|
||
if (status == STATUS_PENDING) {
|
||
|
||
status = KeWaitForSingleObject(&doneEvent,
|
||
Executive,
|
||
KernelMode,
|
||
FALSE,
|
||
NULL);
|
||
|
||
ASSERT(status == STATUS_SUCCESS);
|
||
|
||
status = Irp->IoStatus.Status;
|
||
}
|
||
|
||
if (!NT_SUCCESS(status)) {
|
||
Irp->IoStatus.Status = status;
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
return status;
|
||
}
|
||
|
||
//
|
||
// Parse the resources to map the memory window
|
||
//
|
||
ResourceList = irpSp->Parameters.StartDevice.AllocatedResources;
|
||
TranslatedResourceList = irpSp->Parameters.StartDevice.AllocatedResourcesTranslated;
|
||
|
||
fullResourceDesc = &ResourceList->List[0];
|
||
fullTranslatedDesc = &TranslatedResourceList->List[0];
|
||
|
||
partialResourceList = &fullResourceDesc->PartialResourceList;
|
||
partialTranslatedList = &fullTranslatedDesc->PartialResourceList;
|
||
|
||
partialResourceDesc = partialResourceList->PartialDescriptors;
|
||
partialTranslatedDesc = partialTranslatedList->PartialDescriptors;
|
||
|
||
if (partialResourceDesc->Type != CmResourceTypeMemory) {
|
||
ASSERT(partialResourceDesc->Type == CmResourceTypeMemory);
|
||
Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
memcardExtension->HostBase = partialTranslatedDesc->u.Memory.Start.QuadPart;
|
||
memcardExtension->MemoryWindowSize = partialTranslatedDesc->u.Memory.Length;
|
||
//
|
||
//
|
||
|
||
switch (partialTranslatedDesc->Type) {
|
||
|
||
case CmResourceTypeMemory:
|
||
memcardExtension->MemoryWindowBase = MmMapIoSpace(partialTranslatedDesc->u.Memory.Start,
|
||
partialTranslatedDesc->u.Memory.Length,
|
||
FALSE);
|
||
memcardExtension->IsMemoryMapped = TRUE;
|
||
break;
|
||
|
||
case CmResourceTypePort:
|
||
memcardExtension->MemoryWindowBase = (PUCHAR) partialResourceDesc->u.Port.Start.QuadPart;
|
||
memcardExtension->IsMemoryMapped = FALSE;
|
||
break;
|
||
|
||
default:
|
||
ASSERT(FALSE);
|
||
Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
//
|
||
// Try to get the capacity of the card
|
||
//
|
||
memcardExtension->ByteCapacity = MemCardGetCapacity(memcardExtension);
|
||
|
||
//
|
||
// If we can't get the capacity, the must be broken in some way
|
||
//
|
||
|
||
if (!memcardExtension->ByteCapacity) {
|
||
Irp->IoStatus.Status = STATUS_UNRECOGNIZED_MEDIA;
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
return STATUS_UNRECOGNIZED_MEDIA;
|
||
}
|
||
|
||
|
||
if (!memcardExtension->NoDrive) {
|
||
pnpStatus = IoRegisterDeviceInterface(memcardExtension->UnderlyingPDO,
|
||
(LPGUID)&MOUNTDEV_MOUNTED_DEVICE_GUID,
|
||
NULL,
|
||
&memcardExtension->InterfaceString);
|
||
|
||
if ( NT_SUCCESS(pnpStatus) ) {
|
||
|
||
pnpStatus = IoSetDeviceInterfaceState(&memcardExtension->InterfaceString,
|
||
TRUE);
|
||
}
|
||
}
|
||
|
||
memcardExtension->IsStarted = TRUE;
|
||
|
||
Irp->IoStatus.Status = status;
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
MemCardPnpComplete (
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN PVOID Context
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
A completion routine for use when calling the lower device objects to
|
||
which our bus (FDO) is attached.
|
||
|
||
--*/
|
||
{
|
||
|
||
KeSetEvent ((PKEVENT) Context, 1, FALSE);
|
||
// No special priority
|
||
// No Wait
|
||
|
||
return STATUS_MORE_PROCESSING_REQUIRED; // Keep this IRP
|
||
}
|
||
|
||
NTSTATUS
|
||
MemCardGetResourceRequirements(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Provides a memory resource requirement in case the bus driver
|
||
doesn't.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - a pointer to the object that represents the device
|
||
that I/O is to be done on.
|
||
|
||
Irp - a pointer to the I/O Request Packet for this request.
|
||
|
||
Return Value:
|
||
|
||
status
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS status;
|
||
KEVENT doneEvent;
|
||
PIO_RESOURCE_REQUIREMENTS_LIST ioResourceRequirementsList;
|
||
PIO_RESOURCE_LIST ioResourceList;
|
||
PIO_RESOURCE_DESCRIPTOR ioResourceDesc;
|
||
PMEMCARD_EXTENSION memcardExtension = (PMEMCARD_EXTENSION)DeviceObject->DeviceExtension;
|
||
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
|
||
ULONG listSize;
|
||
|
||
//
|
||
// First we must pass this Irp on to the PDO.
|
||
//
|
||
KeInitializeEvent(&doneEvent, NotificationEvent, FALSE);
|
||
|
||
IoCopyCurrentIrpStackLocationToNext(Irp);
|
||
|
||
IoSetCompletionRoutine(Irp,
|
||
MemCardPnpComplete,
|
||
&doneEvent,
|
||
TRUE, TRUE, TRUE);
|
||
|
||
status = IoCallDriver(memcardExtension->TargetObject, Irp);
|
||
|
||
if (status == STATUS_PENDING) {
|
||
|
||
status = KeWaitForSingleObject(&doneEvent,
|
||
Executive,
|
||
KernelMode,
|
||
FALSE,
|
||
NULL);
|
||
|
||
ASSERT(status == STATUS_SUCCESS);
|
||
|
||
status = Irp->IoStatus.Status;
|
||
}
|
||
|
||
if (NT_SUCCESS(status) && (Irp->IoStatus.Information == 0)) {
|
||
|
||
listSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST);
|
||
|
||
ioResourceRequirementsList = (PIO_RESOURCE_REQUIREMENTS_LIST) ExAllocatePool(PagedPool, listSize);
|
||
|
||
RtlZeroMemory(ioResourceRequirementsList, listSize);
|
||
|
||
ioResourceRequirementsList->ListSize = listSize;
|
||
ioResourceRequirementsList->AlternativeLists = 1;
|
||
//
|
||
// NOTE: not quite sure if the following values are the best choices
|
||
//
|
||
ioResourceRequirementsList->InterfaceType = Isa;
|
||
ioResourceRequirementsList->BusNumber = 0;
|
||
ioResourceRequirementsList->SlotNumber = 0;
|
||
|
||
ioResourceList = &ioResourceRequirementsList->List[0];
|
||
|
||
ioResourceList->Version = 1;
|
||
ioResourceList->Revision = 1;
|
||
ioResourceList->Count = 1;
|
||
|
||
ioResourceDesc = &ioResourceList->Descriptors[0];
|
||
ioResourceDesc->Option = 0;
|
||
ioResourceDesc->Type = CmResourceTypeMemory;
|
||
ioResourceDesc->Flags = CM_RESOURCE_MEMORY_READ_WRITE;
|
||
ioResourceDesc->ShareDisposition = CmResourceShareDeviceExclusive;
|
||
ioResourceDesc->u.Memory.MinimumAddress.QuadPart = 0;
|
||
ioResourceDesc->u.Memory.MaximumAddress.QuadPart = (ULONGLONG)-1;
|
||
ioResourceDesc->u.Memory.Length = 0x2000;
|
||
ioResourceDesc->u.Memory.Alignment = 0x2000;
|
||
|
||
Irp->IoStatus.Information = (ULONG_PTR)ioResourceRequirementsList;
|
||
}
|
||
Irp->IoStatus.Status = status;
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
MemCardGetDeviceParameters(
|
||
IN PMEMCARD_EXTENSION memcardExtension
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Loads device specific parameters from the registry
|
||
|
||
Arguments:
|
||
|
||
memcardExtension - device extension of the device
|
||
|
||
Return Value:
|
||
|
||
status
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS status;
|
||
HANDLE instanceHandle;
|
||
UNICODE_STRING KeyName;
|
||
UCHAR buffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 32*sizeof(UCHAR)];
|
||
PKEY_VALUE_PARTIAL_INFORMATION value = (PKEY_VALUE_PARTIAL_INFORMATION) buffer;
|
||
ULONG length;
|
||
|
||
if (!memcardExtension->UnderlyingPDO) {
|
||
return STATUS_UNSUCCESSFUL;
|
||
}
|
||
|
||
status = IoOpenDeviceRegistryKey(memcardExtension->UnderlyingPDO,
|
||
PLUGPLAY_REGKEY_DRIVER,
|
||
KEY_READ,
|
||
&instanceHandle
|
||
);
|
||
if (!NT_SUCCESS(status)) {
|
||
return(status);
|
||
}
|
||
|
||
//
|
||
// Read in the "NoDrive" parameter
|
||
//
|
||
|
||
RtlInitUnicodeString(&KeyName, MEMCARD_REGISTRY_NODRIVE_KEY);
|
||
|
||
status = ZwQueryValueKey(instanceHandle,
|
||
&KeyName,
|
||
KeyValuePartialInformation,
|
||
value,
|
||
sizeof(buffer),
|
||
&length);
|
||
|
||
if (NT_SUCCESS(status)) {
|
||
memcardExtension->NoDrive = (BOOLEAN) (*(PULONG)(value->Data) != 0);
|
||
}
|
||
|
||
//
|
||
// Read in the MTD name
|
||
//
|
||
|
||
RtlInitUnicodeString(&KeyName, MEMCARD_REGISTRY_MTD_KEY);
|
||
|
||
status = ZwQueryValueKey(instanceHandle,
|
||
&KeyName,
|
||
KeyValuePartialInformation,
|
||
value,
|
||
sizeof(buffer),
|
||
&length);
|
||
|
||
if (NT_SUCCESS(status)) {
|
||
UNICODE_STRING TechnologyName;
|
||
|
||
RtlInitUnicodeString(&TechnologyName, (PVOID)value->Data);
|
||
|
||
status = MemCardInitializeMtd(memcardExtension, &TechnologyName);
|
||
}
|
||
|
||
ZwClose(instanceHandle);
|
||
return status;
|
||
}
|