/*++
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;
}