windows-server-2003/base/busdrv/pccard/pcmcibus/detect.c

/*++

Copyright (c) 1997-2000 Microsoft Corporation

Module Name:

    detect.c

Abstract:

    This module contains the code that controls the PCMCIA slots.

Authors:

    Bob Rinne (BobRi) 3-Nov-1994
    Neil Sandlin (neilsa) June 1 1999

Environment:

    Kernel mode

Revision History:
    Modified for plug'n'play support
         Ravisankar Pudipeddi (ravisp) 1 Dec 1996


--*/

#include "pch.h"


NTSTATUS
PcmciaDetectControllers(
    IN PDRIVER_OBJECT           DriverObject,
    IN PUNICODE_STRING          RegistryPath,
    IN PPCMCIA_DETECT_ROUTINE   PcmciaDetectFn
    );

NTSTATUS
PcmciaReportDetectedDevice(
    IN PFDO_EXTENSION DeviceExtension
    );

NTSTATUS
PcmciaAllocateOpenMemoryWindow(
    IN PFDO_EXTENSION DeviceExtension,
    IN PPHYSICAL_ADDRESS PhysicalAddress,
    IN PULONG PhysicalAddressSize
    );


#ifdef ALLOC_PRAGMA
//   #pragma alloc_text(INIT,PcmciaLegacyDetectionOk)
    #pragma alloc_text(INIT,PcmciaDetectPcmciaControllers)
    #pragma alloc_text(INIT,PcmciaDetectControllers)
    #pragma alloc_text(INIT,PcmciaReportDetectedDevice)
    #pragma alloc_text(INIT,PcmciaAllocateOpenMemoryWindow)
#endif


#if 0

BOOLEAN
PcmciaLegacyDetectionOk(
    VOID
    )
/*++

Routine Description

     Checks if legacy detection needs to be done for pcmcia controllers

Arguments

     None

Return Value

     TRUE   - If legacy detection can be done
     FALSE  - If legacy detection should NOT be attempted

--*/
{
    UNICODE_STRING                   unicodeKey, unicodeValue;
    OBJECT_ATTRIBUTES                objectAttributes;
    HANDLE                           handle;
    UCHAR                            buffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION)+
                                                      sizeof(ULONG)];
    PKEY_VALUE_PARTIAL_INFORMATION value = (PKEY_VALUE_PARTIAL_INFORMATION) buffer;
    ULONG                            length;
    NTSTATUS                         status;

    PAGED_CODE();

    RtlInitUnicodeString(&unicodeKey,
                                L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Pnp");

    RtlZeroMemory(&objectAttributes, sizeof(OBJECT_ATTRIBUTES));
    InitializeObjectAttributes(&objectAttributes,
                               &unicodeKey,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);

    if (!NT_SUCCESS(ZwOpenKey(&handle,
                              KEY_QUERY_VALUE,
                              &objectAttributes))) {
        //
        // Key doesn't exist
        //
        return TRUE;
    }

    RtlInitUnicodeString(&unicodeValue, L"DisableFirmwareMapper");

    status =  ZwQueryValueKey(handle,
                              &unicodeValue,
                              KeyValuePartialInformation,
                              value,
                              sizeof(buffer),
                              &length);
    ZwClose(handle);

    if (!NT_SUCCESS(status)) {
        //
        // Value doesn't exist
        //
        return TRUE;
    }

    if (value->Type == REG_DWORD) {
        //
        // If value is non-zero don't do legacy detection
        // otherwise it's ok
        //
        return  ((ULONG) (*((PULONG)value->Data)) ? FALSE : TRUE);
    }
    return TRUE;
}
#endif



NTSTATUS
PcmciaDetectPcmciaControllers(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath
    )
/*++

Routine Description:
    Detects appropriate PCMCIA controllers both ISA & PCI based
    in the system.

Arguments:

    DriverObject     Just as passed in to DriverEntry
    RegistryPath

Return Value:
    STATUS_SUCCESS if any PCMCIA controllers were found
    STATUS_NO_SUCH_DEVICE otherwise

--*/
{
    NTSTATUS pcicIsaStatus = STATUS_UNSUCCESSFUL, tcicStatus = STATUS_UNSUCCESSFUL;

    PAGED_CODE();

    //
    // We enumerate the PCI devices first to ensure that the ISA detect
    // doesn't probe those address ports which are already claimed by
    // detected PCI devices
    //
    pcicIsaStatus = PcmciaDetectControllers(DriverObject, RegistryPath, PcicIsaDetect);

    tcicStatus = PcmciaDetectControllers(DriverObject, RegistryPath, TcicDetect);

    //
    // Indicate success if we found any controllers
    //
    return ((NT_SUCCESS(pcicIsaStatus) ||
                NT_SUCCESS(tcicStatus) ) ? STATUS_SUCCESS : STATUS_NO_SUCH_DEVICE);
}



NTSTATUS
PcmciaDetectControllers(
    IN PDRIVER_OBJECT            DriverObject,
    IN PUNICODE_STRING           RegistryPath,
    IN PPCMCIA_DETECT_ROUTINE    PcmciaDetectFn
    )
/*++

Routine Description:
    Detects PCMCIA controllers in the system and reports them. This is called
    by PcmciaDetectPcmciaControllers. This reports bus specific controllers.

Arguments:
    DriverObject, RegistryPath - See DriverEntry
    PcmciaDetectFn              - Pointer to the function that actually probes the hardware
                                          to find PCMCIA controllers. So this routine can be called
                                          with an ISA detect function or a PCI detect function for eg.

Return Value:
    STATUS_SUCCESS                  Found one or more PCMCIA controllers
    STATUS_NO_SUCH_DEVICE           No controllers found.
    STATUS_INSUFFICIENT_RESOURCES Pool allocation failures etc.

--*/
{

    PFDO_EXTENSION            deviceExtension = NULL;
    NTSTATUS                      status = STATUS_SUCCESS;
    NTSTATUS                      detectStatus;
    BOOLEAN                       controllerDetected = FALSE;

    PAGED_CODE();

    //
    // Allocate a dummy device extension which is used by the Pcic & Tcic detect modules
    // Have to do this since the original detection code required device extensions
    // Too painful to change this structure now.
    //
    deviceExtension = ExAllocatePool(NonPagedPool, sizeof(FDO_EXTENSION));
    if (deviceExtension == NULL) {
        DebugPrint((PCMCIA_DEBUG_FAIL, "Cannot allocate pool for FDO extension\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    do {

        RtlZeroMemory(deviceExtension, sizeof(FDO_EXTENSION));

        deviceExtension->RegistryPath = RegistryPath;
        deviceExtension->DriverObject = DriverObject;

        detectStatus = (*PcmciaDetectFn)(deviceExtension);

        if (detectStatus != STATUS_SUCCESS) {
            continue;
        }

        controllerDetected = TRUE;

        status = PcmciaReportDetectedDevice(deviceExtension);

        if (!NT_SUCCESS(status)) {
            DebugPrint((PCMCIA_DEBUG_FAIL, "PcmciaDetectControllers: PcmciaReportDetectedDevice "
                            "failed, status %x\n", status));
            continue;
        }

    } while (detectStatus != STATUS_NO_MORE_ENTRIES);

    ExFreePool(deviceExtension);

    if (controllerDetected) {
        return STATUS_SUCCESS;
    }

    return (STATUS_NO_SUCH_DEVICE);
}



NTSTATUS
PcmciaReportDetectedDevice(
    IN PFDO_EXTENSION DeviceExtension
    )
/*++

Routine Description:

    Reports the PCMCIA controllers detected to the IO subsystem which creates the
    madeup devnodes for these DeviceObjects.

Arguments:

    DeviceExtension - DeviceExtension for the DeviceObject (FDO) of the PCMCIA controller
                            being reported
Return Value:

--*/
{
    PDEVICE_OBJECT            pdo = NULL, fdo, lowerDevice;
    PFDO_EXTENSION            fdoExtension;
    ULONG                         pcmciaInterruptVector;
    KIRQL                         pcmciaInterruptLevel;
    KAFFINITY                     pcmciaAffinity;
    PSOCKET                       socket;
    NTSTATUS                      status;
    ULONG                         pcmciaIrq;
    ULONG                         count, ioResourceReqSize;
    PHYSICAL_ADDRESS              halMemoryAddress;
    ULONG                         addressSpace;
    PIO_RESOURCE_REQUIREMENTS_LIST  ioResourceReq=NULL;
    PIO_RESOURCE_LIST                 ioResourceList;
    PIO_RESOURCE_DESCRIPTOR           ioResourceDesc;
    PCM_RESOURCE_LIST                 allocatedResources;
    PCM_RESOURCE_LIST                 scratchResources;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR cmResourceDesc;
    BOOLEAN                       translated;
    UCHAR                         option;

    PAGED_CODE();

    //
    // Do initial setup in our "fake" device extension
    //
    PcmciaGetControllerRegistrySettings(DeviceExtension);

    DeviceExtension->Configuration.InterruptPin = 0;
    DeviceExtension->Configuration.Interrupt.u.Interrupt.Vector = 0;
    DeviceExtension->Configuration.Interrupt.u.Interrupt.Level = 0;

    count=0;
    //
    // Get an 'open' memory window
    //
    status = PcmciaAllocateOpenMemoryWindow(DeviceExtension,
                                            &DeviceExtension->PhysicalBase,
                                            &DeviceExtension->AttributeMemorySize);
    count++;

    if (DeviceExtension->Configuration.UntranslatedPortAddress) {
        count++;
    }

    ioResourceReqSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST) + (count-1)*sizeof(IO_RESOURCE_DESCRIPTOR);

    ioResourceReq = ExAllocatePool(PagedPool, ioResourceReqSize);
    if (ioResourceReq == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    RtlZeroMemory(ioResourceReq, ioResourceReqSize);

    ioResourceReq->ListSize = ioResourceReqSize;
    ioResourceReq->InterfaceType = Isa; // DeviceExtension->Configuration.InterfaceType;
    ioResourceReq->BusNumber = DeviceExtension->Configuration.BusNumber;
    ioResourceReq->SlotNumber= DeviceExtension->Configuration.SlotNumber;
    ioResourceReq->AlternativeLists=1;

    ioResourceList = &(ioResourceReq->List[0]);
    ioResourceList->Version  = IO_RESOURCE_LIST_VERSION;
    ioResourceList->Revision = IO_RESOURCE_LIST_REVISION;
    ioResourceList->Count    = count;

    ioResourceDesc = ioResourceList->Descriptors;

    //
    //Request IO
    //
    if (DeviceExtension->Configuration.UntranslatedPortAddress) {
        ioResourceDesc->Option = 0;
        ioResourceDesc->Type = CmResourceTypePort;
        ioResourceDesc->ShareDisposition = CmResourceShareDeviceExclusive;
        ioResourceDesc->Flags = CM_RESOURCE_PORT_IO;
        ioResourceDesc->u.Port.MinimumAddress.LowPart = (ULONG)(DeviceExtension->Configuration.UntranslatedPortAddress);
        ioResourceDesc->u.Port.MaximumAddress.LowPart = (ULONG)(DeviceExtension->Configuration.UntranslatedPortAddress+
                                                                                   DeviceExtension->Configuration.PortSize - 1);
        ioResourceDesc->u.Port.Length = DeviceExtension->Configuration.PortSize;
        ioResourceDesc->u.Port.Alignment =  1;
        ioResourceDesc++;
    }

    //
    // Request memory
    //
    ioResourceDesc->Option = 0;
    ioResourceDesc->Type = CmResourceTypeMemory;
    ioResourceDesc->ShareDisposition = CmResourceShareDeviceExclusive;
    ioResourceDesc->Flags = CM_RESOURCE_MEMORY_READ_WRITE;
    if (DeviceExtension->PhysicalBase.QuadPart) {
        ioResourceDesc->u.Memory.MinimumAddress = DeviceExtension->PhysicalBase;
        ioResourceDesc->u.Memory.MaximumAddress.QuadPart = DeviceExtension->PhysicalBase.QuadPart+DeviceExtension->AttributeMemorySize-1;
        ioResourceDesc->u.Memory.Length = DeviceExtension->AttributeMemorySize;
        ioResourceDesc->u.Memory.Alignment = 1;
        ioResourceDesc++;
    } else {
        //
        ioResourceDesc->u.Memory.MinimumAddress.LowPart = DeviceExtension->AttributeMemoryLow;
        ioResourceDesc->u.Memory.MaximumAddress.LowPart = DeviceExtension->AttributeMemoryHigh;
        ioResourceDesc->u.Memory.Length = DeviceExtension->AttributeMemorySize;
        switch (DeviceExtension->ControllerType) {

        case PcmciaDatabook: {
                ioResourceDesc->u.Memory.Alignment = TCIC_WINDOW_ALIGNMENT;
                break;
            }
        default: {
                ioResourceDesc->u.Memory.Alignment = PCIC_WINDOW_ALIGNMENT;
                break;
            }
        }
        ioResourceDesc++;
    }


    status = IoAssignResources(DeviceExtension->RegistryPath,
                               NULL,
                               DeviceExtension->DriverObject,
                               NULL,
                               ioResourceReq,
                               &allocatedResources
                               );

    if (!NT_SUCCESS(status)) {
        //
        // Log an event here
        //
        PcmciaLogError(DeviceExtension, PCMCIA_NO_RESOURCES, 1, 0);

        DebugPrint((PCMCIA_DEBUG_FAIL, "PcmciaReportDetectedDevice: IoAssignResources failed status %x\n",
                        status));
        ExFreePool(ioResourceReq);
        return status;
    }


    //
    // Fish out the Memory Base allocated to this controller from the
    // nether depths of the CM_RESOURCE_LIST
    //
    count = allocatedResources->List[0].PartialResourceList.Count;
    cmResourceDesc = &(allocatedResources->List[0].PartialResourceList.PartialDescriptors[0]);

    while (count--) {
        switch (cmResourceDesc->Type) {

        case CmResourceTypeMemory: {

                DeviceExtension->PhysicalBase = cmResourceDesc->u.Memory.Start;
                DeviceExtension->AttributeMemorySize = cmResourceDesc->u.Memory.Length;

                addressSpace=0;
                translated = HalTranslateBusAddress(Isa,
                                                    0,
                                                    cmResourceDesc->u.Memory.Start,
                                                    &addressSpace,
                                                    &halMemoryAddress);
                ASSERT(translated);
                if (addressSpace) {
                    DeviceExtension->AttributeMemoryBase = (PUCHAR)(halMemoryAddress.QuadPart);
                    DeviceExtension->Flags &= ~PCMCIA_ATTRIBUTE_MEMORY_MAPPED;
                }

                else {
                    DeviceExtension->AttributeMemoryBase = MmMapIoSpace(halMemoryAddress,
                                                                        cmResourceDesc->u.Memory.Length,
                                                                        FALSE);
                    DeviceExtension->Flags |= PCMCIA_ATTRIBUTE_MEMORY_MAPPED;
                }
                DebugPrint((PCMCIA_DEBUG_INFO,
                                "Attribute Memory Physical Base: %x Virtual Addr: %x\n",
                                DeviceExtension->PhysicalBase,
                                DeviceExtension->AttributeMemoryBase));
                break;
            }
            // Don't bother to parse IO, it was a fixed resource requirement which we already know about
        }
        cmResourceDesc++;
    }

    //
    // Free resources so IoReportDetectedDevice can assign them for the PDO
    //
    IoAssignResources(DeviceExtension->RegistryPath,
                      NULL,
                      DeviceExtension->DriverObject,
                      NULL,
                      NULL,
                      &scratchResources
                      );

    pdo = NULL;
    status = IoReportDetectedDevice(
                                    DeviceExtension->DriverObject,
                                    InterfaceTypeUndefined,
                                    -1,
                                    -1,
                                    allocatedResources,
                                    ioResourceReq,
                                    FALSE,
                                    &pdo
                                    );

    ExFreePool(allocatedResources);
    ExFreePool(ioResourceReq);

    if (!NT_SUCCESS(status)) {
        DebugPrint((PCMCIA_DEBUG_FAIL, "PcmciaReportDetectedDevice: IoReportDetectedDevice failed\n"));
        return status;
    }

    //
    // Set up registry params for the madeup pdo so we'll recognize it on the next boot
    // when the PNP manager gives us an AddDevice/IRP_MN_START_DEVICE
    //
    PcmciaSetLegacyDetectedControllerType(pdo, DeviceExtension->ControllerType);

    //
    // The I/O subsystem has created the true PDO which we will use during this boot. So we
    // have to attach to this PDO, and initialize our new FDO extension to values already set
    // into our original (fake) FDO extension.
    //

    status = PcmciaAddDevice(DeviceExtension->DriverObject, pdo);

    if (!NT_SUCCESS(status)) {

        DebugPrint((PCMCIA_DEBUG_FAIL, "PcmciaReportDetectedDevice: AddDevice failed status %x\n", status));
        return status;
    }

    pdo->Flags &= ~DO_DEVICE_INITIALIZING;

    //
    // Head of list is our fdo
    //
    fdo = FdoList;
    fdoExtension = fdo->DeviceExtension;

    //
    // Copy in the rest of the config. from the DeviceExtension
    //
    fdoExtension->SocketList = DeviceExtension->SocketList;
    fdoExtension->Configuration = DeviceExtension->Configuration;
    fdoExtension->PhysicalBase = DeviceExtension->PhysicalBase;
    fdoExtension->AttributeMemoryBase = DeviceExtension->AttributeMemoryBase;
    fdoExtension->AttributeMemorySize = DeviceExtension->AttributeMemorySize;
    fdoExtension->Flags = DeviceExtension->Flags;

    // Reinitialize the socket's device extensions
    //
    for (socket = fdoExtension->SocketList; socket!=NULL; socket=socket->NextSocket) {
        socket->DeviceExtension = fdoExtension;
    }

    fdoExtension->Flags |= PCMCIA_DEVICE_STARTED;
    //
    // This is legacy detected..
    //
    fdoExtension->Flags |= PCMCIA_DEVICE_LEGACY_DETECTED;

    status=PcmciaStartPcmciaController(fdo);

    if (!NT_SUCCESS(status)) {
        fdoExtension->Flags &= ~PCMCIA_DEVICE_STARTED;
    }

    return status;
}



NTSTATUS
PcmciaAllocateOpenMemoryWindow(
    IN PFDO_EXTENSION DeviceExtension,
    IN PPHYSICAL_ADDRESS PhysicalAddress,
    IN PULONG PhysicalAddressSize
    )

/*++

Routine Description:

    Search the 640K to 1MB region for an open area to be used
    for mapping PCCARD attribute memory.

Arguments:


Return Value:

    A physical address for the window to the card or zero meaning
    there is no opening.

--*/

{
#define NUMBER_OF_TEST_BYTES 25
    PHYSICAL_ADDRESS physicalMemoryAddress;
    PHYSICAL_ADDRESS halMemoryAddress;
    BOOLEAN           translated;
    ULONG             untranslatedAddress;
    PUCHAR            memoryAddress;
    PUCHAR            bogus;
    ULONG             addressSpace;
    ULONG             index;
    UCHAR             memory[NUMBER_OF_TEST_BYTES];
    PCM_RESOURCE_LIST cmResourceList = NULL;
    PCM_PARTIAL_RESOURCE_LIST cmPartialResourceList;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR cmResourceDesc;
    BOOLEAN conflict = TRUE;
    NTSTATUS                              status;
    ULONG               windowSize, windowAlignment;

    PAGED_CODE();


    cmResourceList = ExAllocatePool(PagedPool, sizeof(CM_RESOURCE_LIST));
    if (!cmResourceList) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    RtlZeroMemory(cmResourceList, sizeof(CM_RESOURCE_LIST));
    cmResourceList->Count = 1;
    cmResourceList->List[0].InterfaceType = Isa;
    cmPartialResourceList = &(cmResourceList->List[0].PartialResourceList);
    cmPartialResourceList->Version  = 1;
    cmPartialResourceList->Revision = 1;
    cmPartialResourceList->Count      = 1;
    cmResourceDesc = cmPartialResourceList->PartialDescriptors;
    cmResourceDesc->Type = CmResourceTypeMemory;
    cmResourceDesc->ShareDisposition = CmResourceShareDeviceExclusive;
    cmResourceDesc->Flags = CM_RESOURCE_MEMORY_READ_WRITE;

    //
    // Size of the attr. memory window
    //
    switch (DeviceExtension->ControllerType) {

    case PcmciaDatabook: {
            windowSize       = TCIC_WINDOW_SIZE;
            windowAlignment = TCIC_WINDOW_ALIGNMENT;
            break;
        }

    default: {
            windowSize = PCIC_WINDOW_SIZE;
            windowAlignment = PCIC_WINDOW_ALIGNMENT;
            break;
        }
    }

    for (untranslatedAddress = DeviceExtension->AttributeMemoryLow;
         untranslatedAddress < DeviceExtension->AttributeMemoryHigh;
         untranslatedAddress += windowAlignment) {

        if (untranslatedAddress == 0xc0000) {

            //
            // This is VGA.  Keep this test if the for loop should
            // ever change.
            //

            continue;
        }

        //
        // Check if it's available
        //
        cmResourceDesc->u.Memory.Start.LowPart = untranslatedAddress;
        cmResourceDesc->u.Memory.Length = windowSize;

        status=IoReportResourceForDetection(
                                            DeviceExtension->DriverObject,
                                            cmResourceList,
                                            sizeof(CM_RESOURCE_LIST),
                                            NULL,
                                            NULL,
                                            0,
                                            &conflict);
        if (!NT_SUCCESS(status) || conflict) {
            //
            // This range's already taken. Move on to the next
            //
            continue;
        }

        addressSpace = 0;
        physicalMemoryAddress.LowPart = untranslatedAddress;
        physicalMemoryAddress.HighPart = 0;

        translated = HalTranslateBusAddress(Isa,
                                            0,
                                            physicalMemoryAddress,
                                            &addressSpace,
                                            &halMemoryAddress);

        if (!translated) {

            //
            // HAL doesn't like this translation
            //

            continue;
        }
        if (addressSpace) {
            memoryAddress = (PUCHAR)(halMemoryAddress.QuadPart);
        } else {
            memoryAddress = MmMapIoSpace(halMemoryAddress, windowSize, FALSE);
        }

        //
        // Test the memory window to determine if it is a BIOS, video
        // memory, or open memory.  Only want to keep the window if it
        // is not being used by something else.
        //

        for (index = 0; index < NUMBER_OF_TEST_BYTES; index++) {
            memory[index] = READ_REGISTER_UCHAR(memoryAddress + index);
            if (index) {
                if (memory[index] != memory[index - 1]) {
                    break;
                }
            }
        }

        if (index == NUMBER_OF_TEST_BYTES) {

            //
            // There isn't a BIOS here
            //

            UCHAR memoryPattern[NUMBER_OF_TEST_BYTES];
            BOOLEAN changed = FALSE;

            //
            // Check for video memory - open memory should always remain
            // the same regardless what the changes are.  Change the
            // pattern previously found.
            //

            for (index = 0; index < NUMBER_OF_TEST_BYTES; index++) {
                memoryPattern[index] = ~memory[index];
                WRITE_REGISTER_UCHAR(memoryAddress + index,
                                     memoryPattern[index]);
            }

            //
            // See if the pattern in memory changed.
            // Some system exhibit a problem where the memory pattern
            // seems to be cached.  If this code is debugged it will
            // work as expected, but if it is run normally it will
            // always return that the memory changed.  This random
            // wandering seems to remove this problem.
            //

            for (index = 0; index < NUMBER_OF_TEST_BYTES; index++) {
                memoryPattern[index] = 0;
            }
            bogus = ExAllocatePool(PagedPool, 64 * 1024);

            if (bogus) {
                for (index = 0; index < 64 * 1024; index++) {
                    bogus[index] = 0;
                }
                ExFreePool(bogus);
            }

            //
            // Now go off and do the actual check to see if the memory
            // changed.
            //

            for (index = 0; index < NUMBER_OF_TEST_BYTES; index++) {

                if ((memoryPattern[index] = READ_REGISTER_UCHAR(memoryAddress + index)) != memory[index]) {

                    //
                    // It changed - this is not an area of open memory
                    //

                    changed = TRUE;
                }
                WRITE_REGISTER_UCHAR(memoryAddress + index,
                                     memory[index]);
            }

            if (!changed) {

                //
                // Area isn't a BIOS and didn't change when written.
                // Use this region for the memory window to PCMCIA
                // attribute memory.
                //

                PhysicalAddress->LowPart = untranslatedAddress;
                PhysicalAddress->HighPart = 0;
                *PhysicalAddressSize = windowSize;
                if (!addressSpace) {
                    MmUnmapIoSpace(memoryAddress, windowSize);
                }
                ExFreePool(cmResourceList);
                return STATUS_SUCCESS;
            }
        }

        if (!addressSpace) {
            MmUnmapIoSpace(memoryAddress, windowSize);
        }
    }
    ExFreePool(cmResourceList);
    return STATUS_UNSUCCESSFUL;
}