windows-xp/Source/XPSP1/NT/base/busdrv/pccard/pcmcibus/fdopnp.c

/*++

Copyright (c) 1997-2000 Microsoft Corporation

Module Name:

    fdopnp.c

Abstract:

    This module contains the code that handles PNP irps for pcmcia bus driver
    targeted towards the FDO's (for the pcmcia controller object)

Author:

    Ravisankar Pudipeddi (ravisp) Oct 15 1996
    Neil Sandlin (neilsa) June 1 1999

Environment:

    Kernel mode

Revision History :

--*/

#include "pch.h"

//
// Internal References
//

NTSTATUS
PcmciaFdoFilterResourceRequirements(
   IN  PDEVICE_OBJECT Fdo,
   IN  PIRP           Irp
   );

NTSTATUS
PcmciaFdoGetHardwareIds(
   IN PDEVICE_OBJECT Fdo,
   OUT PUNICODE_STRING HardwareIds
   );

NTSTATUS
PcmciaFdoStartDevice(
   IN  PDEVICE_OBJECT Fdo,
   IN  PIRP           Irp,
   OUT BOOLEAN        *PassedDown,
   OUT BOOLEAN        *NeedsRecompletion
   );

NTSTATUS
PcmciaFdoStopDevice(
   IN  PDEVICE_OBJECT Fdo,
   IN  PIRP           Irp,
   OUT BOOLEAN        *PassedDown,
   OUT BOOLEAN        *NeedsRecompletion
   );

NTSTATUS
PcmciaFdoRemoveDevice(
   IN PDEVICE_OBJECT Fdo,
   IN PIRP  Irp
   );

VOID
PcmciaCleanupFdo(
   IN PFDO_EXTENSION FdoExtension
   );

NTSTATUS
PcmciaFdoDeviceCapabilities(
   IN  PDEVICE_OBJECT Fdo,
   IN  PIRP           Irp,
   OUT BOOLEAN        *PassedDown,
   OUT BOOLEAN        *NeedsRecompletion
   );

NTSTATUS
PcmciaAreCardBusCardsSupported(
   IN PFDO_EXTENSION FdoExtension
   );

NTSTATUS
PcmciaFdoGetAssignedResources(
   IN PCM_RESOURCE_LIST ResourceList,
   IN PCM_RESOURCE_LIST TranslatedResourceList,
   IN PFDO_EXTENSION    DeviceExtension
   );


#ifdef ALLOC_PRAGMA
   #pragma alloc_text(PAGE, PcmciaFdoPnpDispatch)
   #pragma alloc_text(PAGE, PcmciaFdoGetHardwareIds)
   #pragma alloc_text(PAGE, PcmciaFdoStartDevice)
   #pragma alloc_text(PAGE, PcmciaFdoStopDevice)
   #pragma alloc_text(PAGE, PcmciaFdoRemoveDevice)
   #pragma alloc_text(PAGE, PcmciaFdoFilterResourceRequirements)
   #pragma alloc_text(PAGE, PcmciaFdoGetAssignedResources)
   #pragma alloc_text(PAGE, PcmciaFdoDeviceCapabilities)
   #pragma alloc_text(PAGE, PcmciaAreCardBusCardsSupported)
#endif



NTSTATUS
PcmciaFdoPnpDispatch (
   IN PDEVICE_OBJECT DeviceObject,
   IN PIRP Irp
   )

/*++

Routine Description:

    PNP/Power IRPs dispatch routine for the PCMCIA bus controller

Arguments:

    DeviceObject - Pointer to the device object.
    Irp - Pointer to the IRP

Return Value:

    Status

--*/
{

   PIO_STACK_LOCATION nextIrpStack;
   PIO_STACK_LOCATION irpStack          = IoGetCurrentIrpStackLocation(Irp);
   PFDO_EXTENSION     deviceExtension   = DeviceObject->DeviceExtension;
   NTSTATUS           status            = Irp->IoStatus.Status;
   BOOLEAN            PassedDown        = FALSE;
   BOOLEAN            NeedsReCompletion = FALSE;

   PAGED_CODE();

#if DBG
   if (irpStack->MinorFunction > IRP_MN_PNP_MAXIMUM_FUNCTION) {
      DebugPrint((PCMCIA_DEBUG_PNP, "fdo %08x irp %08x - Unknown PNP irp\n",
                                     DeviceObject, irpStack->MinorFunction));
   } else {
      DebugPrint((PCMCIA_DEBUG_PNP, "fdo %08x irp %08x --> %s\n",
                    DeviceObject, Irp, PNP_IRP_STRING(irpStack->MinorFunction)));
   }
#endif

   switch (irpStack->MinorFunction) {

   case IRP_MN_START_DEVICE: {
         status = PcmciaFdoStartDevice(DeviceObject,
                                       Irp,
                                       &PassedDown,
                                       &NeedsReCompletion);
         break;
      }

   case IRP_MN_QUERY_STOP_DEVICE: {
         status = STATUS_SUCCESS;
         break;
      }

   case IRP_MN_CANCEL_STOP_DEVICE: {
         status = STATUS_SUCCESS;
         break;
      }

   case IRP_MN_STOP_DEVICE: {
         status = PcmciaFdoStopDevice(DeviceObject,
                                      Irp,
                                      &PassedDown,
                                      &NeedsReCompletion);

         break;
      }

   case IRP_MN_QUERY_DEVICE_RELATIONS: {

         //
         // Return the list of devices on the bus
         //

         status = PcmciaDeviceRelations(
                                       DeviceObject,
                                       Irp,
                                       irpStack->Parameters.QueryDeviceRelations.Type,
                                       (PDEVICE_RELATIONS *) &Irp->IoStatus.Information
                                       );
         break;
      }

   case IRP_MN_FILTER_RESOURCE_REQUIREMENTS: {
         status = PcmciaFdoFilterResourceRequirements(DeviceObject, Irp);
         PassedDown = TRUE;
         NeedsReCompletion = TRUE;
         break;
      }

   case IRP_MN_QUERY_REMOVE_DEVICE: {
         status = STATUS_SUCCESS;
         break;
      }

   case IRP_MN_CANCEL_REMOVE_DEVICE: {
         status = STATUS_SUCCESS;
         break;
      }

   case IRP_MN_REMOVE_DEVICE:{
         status = PcmciaFdoRemoveDevice(DeviceObject, Irp);
         PassedDown = TRUE ;
         NeedsReCompletion = TRUE ;
         break;
      }

   case IRP_MN_SURPRISE_REMOVAL: {
         PcmciaFdoStopDevice(DeviceObject, NULL, NULL, NULL);
         status = STATUS_SUCCESS;
         break;
      }

   case IRP_MN_QUERY_ID: {

         UNICODE_STRING unicodeId;

         if (deviceExtension->Flags & PCMCIA_DEVICE_LEGACY_DETECTED) {

            RtlInitUnicodeString(&unicodeId, NULL);

            switch (irpStack->Parameters.QueryId.IdType) {

            case BusQueryHardwareIDs: {

                  DebugPrint((PCMCIA_DEBUG_INFO, " Hardware Ids for fdo %x\n", DeviceObject));
                  status = PcmciaFdoGetHardwareIds(DeviceObject, &unicodeId);

                  if (NT_SUCCESS(status)) {
                     Irp->IoStatus.Information = (ULONG_PTR) unicodeId.Buffer;
                  }
                  break;
               }
            }
         }
         break;
      }

   case IRP_MN_QUERY_CAPABILITIES: {
         status = PcmciaFdoDeviceCapabilities(DeviceObject,
                                              Irp,
                                              &PassedDown,
                                              &NeedsReCompletion);
         break;
      }

   case IRP_MN_QUERY_LEGACY_BUS_INFORMATION:
         //
         // If this FDO represents a CardBus bridge, we pass this irp down
         // to the PCI PDO which will fill in the PCI bus type and number,
         // otherwise we fail the IRP.
         //

         if (!CardBusExtension(deviceExtension)) {
             status = STATUS_NOT_IMPLEMENTED;
         }

         //
         // if status is still STATUS_NOT_SUPPORTED, then later code will pass
         // this irp down the stack.
         //
         break;

   default: {
         DebugPrint((PCMCIA_DEBUG_PNP, "fdo %08x irp %08x - Skipping unsupported irp\n", DeviceObject, Irp));
         break;
      }
   }


   if (!PassedDown) {
       //
       // Set the IRP status only if we set it to something other than
       // STATUS_NOT_SUPPORTED.
       //
       if (status != STATUS_NOT_SUPPORTED) {

           Irp->IoStatus.Status = status ;
       }
       //
       // Pass down if success or STATUS_NOT_SUPPORTED. Otherwise, Complete.
       //
       if (NT_SUCCESS(status) || (status == STATUS_NOT_SUPPORTED)) {

           DebugPrint((PCMCIA_DEBUG_PNP, "fdo %08x irp %08x pass %s %08x\n",
                                               DeviceObject, Irp,
                                               STATUS_STRING(Irp->IoStatus.Status), Irp->IoStatus.Status));
           //
           // Below macro fills status with return of IoCallDriver. It does
           // not change the Irps status in any way.
           //
           PcmciaSkipCallLowerDriver(status, deviceExtension->LowerDevice, Irp);

       } else {
           DebugPrint((PCMCIA_DEBUG_PNP, "fdo %08x irp %08x comp %s %08x\n",
                                               DeviceObject, Irp,
                                               STATUS_STRING(status), status));
           IoCompleteRequest(Irp, IO_NO_INCREMENT);
       }

   } else if (NeedsReCompletion) {
       //
       // Set the IRP status only if we set it to something other than
       // STATUS_NOT_SUPPORTED.
       //
       if (status != STATUS_NOT_SUPPORTED) {

           Irp->IoStatus.Status = status ;
       }

       status = Irp->IoStatus.Status ;
       DebugPrint((PCMCIA_DEBUG_PNP, "fdo %08x irp %08x comp %s %08x\n",
                                           DeviceObject, Irp,
                                           STATUS_STRING(status), status));
       IoCompleteRequest(Irp, IO_NO_INCREMENT);
   }

   return status ;
}



NTSTATUS
PcmciaFdoDeviceCapabilities(
   IN  PDEVICE_OBJECT Fdo,
   IN  PIRP           Irp,
   OUT BOOLEAN        *PassedDown,
   OUT BOOLEAN        *NeedsRecompletion
   )
/*++

Routine Description
   Records the device capabilities of this pcmcia controller,
   so  1. they can be used in the power management for the controller
   and 2. they can be used for determining the capabilities of the
          child pc-card PDO's of this pcmcia controller.
   If this is legacy detected pcmcia controller (ISA-based), the pdo for
   the pcmcia controller is a dummy madeup device - hence  the capabilities
   are filled in by ourselves.
   Otherwise, the capabilities are obtained by sending down the Irp
   to the parent bus.
   In either case, the capabilities are cached in the device extension of
   the pcmcia controller for future use.

Arguments

   Fdo               - Pointer to functional device object of the pcmcia
                       controller
   Irp               - Pointer to the i/o request packet
   PassedDown        - Contains FALSE on entry, which means caller must
                       complete or pass down irp based on status. If set
                       to TRUE, Irp may need to be re-completed...
   NeedsRecompletion - ...In which case this parameter will be checked

Return Value

   STATUS_SUCCESS                       Capabilities returned
   STATUS_INSUFFICIENT_RESOURCES        Could not allocate memory to cache the capabilities

--*/
{
   PFDO_EXTENSION fdoExtension;
   PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
   PDEVICE_CAPABILITIES capabilities;
   NTSTATUS       status;

   PAGED_CODE();

   capabilities = irpStack->Parameters.DeviceCapabilities.Capabilities;
   fdoExtension = Fdo->DeviceExtension;

   if (fdoExtension->Flags & PCMCIA_DEVICE_LEGACY_DETECTED) {

      //
      // This is a madeup devnode (ISA based PCMCIA controller).
      // Fill in the capabilities ourselves
      //
      RtlZeroMemory(capabilities,
                    sizeof(DEVICE_CAPABILITIES));
      //
      // Non removable, non ejectable
      //
      capabilities->Removable      = FALSE;
      capabilities->UniqueID       = FALSE;
      capabilities->EjectSupported = FALSE;
      //
      // Address & number need work..
      //
      capabilities->Address  = -1;
      capabilities->UINumber = -1;
      //
      // We cannot power down this controller
      //
      capabilities->DeviceState[PowerSystemSleeping1] = PowerDeviceD0;
      capabilities->DeviceState[PowerSystemSleeping2] = PowerDeviceD0;
      capabilities->DeviceState[PowerSystemSleeping3] = PowerDeviceD0;
      capabilities->DeviceState[PowerSystemHibernate] = PowerDeviceD3;
      //
      // Obviously wake is not supported on this legacy detected
      // piece of xxxx
      //
      capabilities->SystemWake = PowerSystemUnspecified;
      capabilities->DeviceWake = PowerDeviceUnspecified;
      capabilities->D1Latency = 0;
      capabilities->D2Latency = 0;
      capabilities->D3Latency = 0;
      status = STATUS_SUCCESS;
   } else {

      //
      // Either a PCI-PCMCIA bridge or PCI-Cardbus bridge
      // Send this down the stack to obtain the capabilities
      //
      ASSERT (fdoExtension->LowerDevice != NULL);
      
      status = PcmciaIoCallDriverSynchronous(fdoExtension->LowerDevice, Irp);

      *PassedDown        = TRUE ;
      *NeedsRecompletion = TRUE ;
   }

   if (NT_SUCCESS(status)) {
   
      //
      // NOTE: HACKHACK:
      //
      // Here we provide an option to override the device wake of the pcmcia controller.
      // There are several controllers, notably TI 12xx controllers, which say they
      // can wake from D3, but really can effectively only do WOL from D2. That's because they
      // turn of socket power when put into D3. They fixed this on the TI 14xx line.
      //
      // So here we update the device wake field, and potentially the device states from the BIOS.
      // Note that this has to be used carefully, and only override a particular BIOS's settings
      // where it has been verified the device still works at the lower (more awake) device state.
      //   
      if (PcmciaControllerDeviceWake) {
         if (PcmciaControllerDeviceWake < capabilities->DeviceWake) {
            capabilities->DeviceWake = PcmciaControllerDeviceWake;
         }            
         if (PcmciaControllerDeviceWake < capabilities->DeviceState[PowerSystemSleeping1]) {
            capabilities->DeviceState[PowerSystemSleeping1] = PcmciaControllerDeviceWake;
         }            
         if (PcmciaControllerDeviceWake < capabilities->DeviceState[PowerSystemSleeping2]) {
            capabilities->DeviceState[PowerSystemSleeping2] = PcmciaControllerDeviceWake;
         }            
         if (PcmciaControllerDeviceWake < capabilities->DeviceState[PowerSystemSleeping3]) {
            capabilities->DeviceState[PowerSystemSleeping3] = PcmciaControllerDeviceWake;
         }
      }      
   
      //
      // Cache the device capabilities in the device extension
      // for this pcmcia controller.
      //
      RtlCopyMemory(&fdoExtension->DeviceCapabilities,
                    capabilities,
                    sizeof(DEVICE_CAPABILITIES));

   } else {

      RtlZeroMemory(&fdoExtension->DeviceCapabilities, sizeof(DEVICE_CAPABILITIES));
   
   }

   return status;
}



NTSTATUS
PcmciaFdoFilterResourceRequirements(
   IN PDEVICE_OBJECT Fdo,
   IN PIRP           Irp
   )
/*++

Routine Description

    Filters Resource requirements for PCMCIA controllers generated
    by the bus driver controlling the PDO for the PCMCIA controller.
    Currently adds memory range as an additional resource requirement
    since the BAR doesn't specify this

    Note for CardBus controllers:
    It is necessary to request an attribute memory window here for
    reading CIS of 16-bit PC-Cards - we need a 24 bit address for that,
    and this is the most elegant way of doing it - instead of
    special casing it in PCI driver

Arguments

    DeviceExtension - Pointer to extension for the PCMCIA controller in question
    IoReqList       - Pointer the the original resource requiremnts ejected by
                      the bus driver
    FilteredRequirements - Pointer to the filtered resource req. list will be returned
                           in this variable

Return Value:

    STATUS_SUCCESS  if filtering is successful
    Any other status - could not filter

--*/
{

   PFDO_EXTENSION                  fdoExtension = Fdo->DeviceExtension;
   PIO_RESOURCE_REQUIREMENTS_LIST  oldReqList;
   PIO_RESOURCE_REQUIREMENTS_LIST  newReqList;
   PIO_RESOURCE_LIST               oldList, newList;
   PIO_RESOURCE_DESCRIPTOR         ioResourceDesc;
   ULONG                           newReqSize;
   ULONG                           oldlistSize, newlistSize, altListSize;
   ULONG                           index;
   ULONG                           IntCount = 0;
   PIO_STACK_LOCATION  irpStack = IoGetCurrentIrpStackLocation(Irp);
   NTSTATUS                        status;

   PAGED_CODE();

   status = PcmciaIoCallDriverSynchronous(fdoExtension->LowerDevice, Irp);

   if (!NT_SUCCESS(status)) {
      return status;
   }

   if (Irp->IoStatus.Information == 0) {

      oldReqList = irpStack->Parameters.FilterResourceRequirements.IoResourceRequirementList;

      if (oldReqList == NULL) {
         //
         // NULL List, nothing to do
         //
         return(Irp->IoStatus.Status);
      }

   } else {
      //
      // Use the returned list
      //
      oldReqList = (PIO_RESOURCE_REQUIREMENTS_LIST)Irp->IoStatus.Information;
   }


   //
   // Add an alternative list without the IRQ requirement, if one exists. Model the
   // new alternative list after the first list.
   //

   oldList = oldReqList->List;
   ioResourceDesc = oldList->Descriptors;
   altListSize = 0;

   for (index = 0; index < oldList->Count; index++) {
      // Count the descriptors, excluding any IRQ descriptors
      if (ioResourceDesc->Type == CmResourceTypeInterrupt) {
         IntCount++;
      }
      ioResourceDesc++;
   }

   if (IntCount) {
      //
      // "+1" because we are adding two later, but IO_RESOURCE_LIST already has 1
      //
      altListSize = sizeof(IO_RESOURCE_LIST) + ((oldList->Count+1)-IntCount)*sizeof(IO_RESOURCE_DESCRIPTOR);
   }

   //
   // Add a memory range requirement to what we already have..
   //
   newReqSize = oldReqList->ListSize +
                oldReqList->AlternativeLists*2*sizeof(IO_RESOURCE_DESCRIPTOR) +
                altListSize;
   newReqList = ExAllocatePool(PagedPool, newReqSize);

   if (newReqList == NULL) {
      return STATUS_INSUFFICIENT_RESOURCES;
   }

   RtlCopyMemory(newReqList, oldReqList, FIELD_OFFSET(IO_RESOURCE_REQUIREMENTS_LIST, List));
   newReqList->ListSize = newReqSize;

   newList = newReqList->List;
   oldList = oldReqList->List;

   for (index = 0; index < oldReqList->AlternativeLists; index++) {
      //
      // Compute the size of the current original list
      //
      oldlistSize = sizeof(IO_RESOURCE_LIST) + (oldList->Count-1) * sizeof(IO_RESOURCE_DESCRIPTOR);
      newlistSize = oldlistSize;
      RtlCopyMemory(newList, oldList, newlistSize);

      //
      // Add memory requirement
      //
      ioResourceDesc = (PIO_RESOURCE_DESCRIPTOR) (((PUCHAR) newList) + newlistSize);

      ioResourceDesc->Option = IO_RESOURCE_PREFERRED;
      ioResourceDesc->Type = CmResourceTypeMemory;
      ioResourceDesc->ShareDisposition = CmResourceShareDeviceExclusive;
      ioResourceDesc->Flags = CM_RESOURCE_MEMORY_READ_WRITE;
      ioResourceDesc->u.Memory.MinimumAddress.QuadPart = fdoExtension->AttributeMemoryLow;
      ioResourceDesc->u.Memory.MaximumAddress.QuadPart = fdoExtension->AttributeMemoryHigh;
      ioResourceDesc->u.Memory.Length                  = fdoExtension->AttributeMemorySize;
      ioResourceDesc->u.Memory.Alignment               = fdoExtension->AttributeMemoryAlignment;
      ioResourceDesc++;
      //
      // The other - less restrictive - alternative.
      //
      ioResourceDesc->Option = IO_RESOURCE_ALTERNATIVE;
      ioResourceDesc->Type = CmResourceTypeMemory;
      ioResourceDesc->ShareDisposition = CmResourceShareDeviceExclusive;
      ioResourceDesc->Flags = CM_RESOURCE_MEMORY_READ_WRITE;
      ioResourceDesc->u.Memory.MinimumAddress.QuadPart = 0;
      if ((fdoExtension->Flags & PCMCIA_MEMORY_24BIT) == 0) {
         ioResourceDesc->u.Memory.MaximumAddress.QuadPart = 0xFFFFFFFF;
      } else {
         ioResourceDesc->u.Memory.MaximumAddress.QuadPart = 0xFFFFFF;
      }
      ioResourceDesc->u.Memory.Length    = fdoExtension->AttributeMemorySize;
      ioResourceDesc->u.Memory.Alignment = fdoExtension->AttributeMemoryAlignment;

      newList->Count += 2;
      newlistSize += 2*sizeof(IO_RESOURCE_DESCRIPTOR);

      oldList = (PIO_RESOURCE_LIST) (((PUCHAR) oldList) + oldlistSize);
      newList = (PIO_RESOURCE_LIST) (((PUCHAR) newList) + newlistSize);
   }

   if (altListSize != 0) {
      PIO_RESOURCE_DESCRIPTOR oldResourceDesc;
      //
      // Here we add the alternate list which doesn't contain an IRQ requirement.
      // Note that we use the first "new list" as the "old list". This way, we
      // pick up the things we added in the previous loop. All we have to do is
      // copy every descriptor except for the interrupt descriptor.
      //
      // Note: newList is still set from previous loop
      //
      oldList = newReqList->List;

      //
      // First copy the basic structure without the descriptors
      //
      RtlCopyMemory(newList, oldList, sizeof(IO_RESOURCE_LIST) - sizeof(IO_RESOURCE_DESCRIPTOR));

      oldResourceDesc = oldList->Descriptors;
      ioResourceDesc = newList->Descriptors;

      for (index = 0; index < oldList->Count; index++) {

         if (oldResourceDesc->Type != CmResourceTypeInterrupt) {
            *ioResourceDesc = *oldResourceDesc;
            ioResourceDesc++;

         } else {
            //
            // We've deleted a descriptor
            //
            newList->Count--;
         }
         oldResourceDesc++;
      }
      newReqList->AlternativeLists++;
   }


   Irp->IoStatus.Information = (ULONG_PTR) newReqList;
   irpStack->Parameters.FilterResourceRequirements.IoResourceRequirementList =
                                                                  newReqList;

   //
   // Free up the old resource reqs
   //
   ExFreePool(oldReqList);

   fdoExtension->Flags |= PCMCIA_FILTER_ADDED_MEMORY;
   return STATUS_SUCCESS;
}



NTSTATUS
PcmciaFdoGetHardwareIds(
   IN PDEVICE_OBJECT Fdo,
   OUT PUNICODE_STRING HardwareIds
   )

/*++

Routine description:

    This routine returns the hardware ids for the given 'legacy' pcmcia controller
    NOTE: this routine is required only for pcmcia controllers detected by this driver
    itself and registered via IoReportDetectedDevice.

Arguments:

   Fdo - Pointer to the functional device object representing the pcmcia controller
   CompatibleIds - Pointer to the unicode string which would contain the hardware ids
                   as a multi-string on return

Return value:

   STATUS_SUCCESS
   Any other status - could not generate compatible ids
--*/

{
   PCSTR    strings[2];
   PCMCIA_CONTROLLER_TYPE controllerType;
   ULONG    count, index;
   BOOLEAN  found;

   PAGED_CODE();

   controllerType  = ((PFDO_EXTENSION)Fdo->DeviceExtension)->ControllerType;
   found = FALSE;

   for (index = 0; (PcmciaAdapterHardwareIds[index].ControllerType != PcmciaInvalidControllerType); index++) {
      if (PcmciaAdapterHardwareIds[index].ControllerType == controllerType) {
         found = TRUE;
         break;
      }
   }

   if (found) {
      strings[0] = PcmciaAdapterHardwareIds[index].Id;
   } else {
      DebugPrint((PCMCIA_DEBUG_INFO, "PcmciaGetAdapterHardwareIds: Could not find find hardware id for %x, controllerType %x\n",
                  Fdo,
                  controllerType
                 ));

      strings[0] = "";
   }

   count = 1;
   return PcmciaStringsToMultiString(strings,
                                     count,
                                     HardwareIds);
}




NTSTATUS
PcmciaFdoStartDevice(
   IN  PDEVICE_OBJECT Fdo,
   IN  PIRP           Irp,
   OUT BOOLEAN        *PassedDown,
   OUT BOOLEAN        *NeedsRecompletion
   )
/*++

Routine Description:

    This routine will start the PCMCIA controller with the supplied
    resources.  The IRP is sent down to the pdo first, so PCI or ISAPNP
    or whoever sits underneath gets a chance to program the controller
    to decode the resources.

Arguments:

    Fdo               - Functional device object of the PCMCIA controller
    Irp               - Well, it's the start irp, yah?
    PassedDown        - Contains FALSE on entry, which means caller must
                        complete or pass down irp based on status. If set
                        to TRUE, Irp may need to be re-completed...
    NeedsRecompletion - ...In which case this parameter will be checked

Return value:

    Status

--*/
{
   NTSTATUS           status;
   PFDO_EXTENSION     deviceExtension = Fdo->DeviceExtension;
   PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
   PCM_RESOURCE_LIST  resList, translatedResList, newResList, newTranslatedResList;

   PAGED_CODE();

   if (deviceExtension->Flags & PCMCIA_DEVICE_STARTED) {
      //
      // Start to already started device
      //
      DebugPrint((PCMCIA_DEBUG_FAIL,"PcmciaFdoStartDevice: Fdo %x already started\n",
                  Fdo));
      return STATUS_SUCCESS;
   }

   //
   // Parse AllocatedResources & get IoPort/AttributeMemoryBase/IRQ info.
   //
   status = PcmciaFdoGetAssignedResources(irpStack->Parameters.StartDevice.AllocatedResources,
                                          irpStack->Parameters.StartDevice.AllocatedResourcesTranslated,
                                          deviceExtension
                                          );

   if (!NT_SUCCESS(status)) {
      //
      // Ha. This is most likely a START for a madeup devnode (report-detected legacy PCMCIA controller)
      // which has been removed subsequently, hence not reported again with proper resources.
      // We return an appropriate status
      //
      DebugPrint((PCMCIA_DEBUG_FAIL, "Pcmcia: No  resources assigned to FDO, probably bogus START for"
                  "non-existent controller\n" ));
      return STATUS_NO_SUCH_DEVICE;
   }

   DebugPrint((PCMCIA_DEBUG_PNP, "fdo %08x StartAdapter: AttrMem Base %x\n", Fdo, deviceExtension->PhysicalBase));
   DebugPrint((PCMCIA_DEBUG_PNP, "                       VirtualBase %x AttrMem Size %x\n", deviceExtension->AttributeMemoryBase, deviceExtension->AttributeMemorySize));

   if (deviceExtension->Flags & PCMCIA_FILTER_ADDED_MEMORY) {
      ULONG newSize;
      ULONG index;
      PCM_PARTIAL_RESOURCE_LIST  resPartialList, translatedResPartialList;
      PCM_PARTIAL_RESOURCE_DESCRIPTOR resDesc, translatedResDesc;
      PCM_PARTIAL_RESOURCE_DESCRIPTOR newResDesc, newTranslatedResDesc;
      //
      // We need to remove the memory resource requirement
      //
      resList= irpStack->Parameters.StartDevice.AllocatedResources;
      resPartialList = &resList->List[0].PartialResourceList;
      translatedResList= irpStack->Parameters.StartDevice.AllocatedResourcesTranslated;
      translatedResPartialList = &translatedResList->List[0].PartialResourceList;

      newSize = sizeof(CM_RESOURCE_LIST) + (resPartialList->Count-2)*sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
      newResList = ExAllocatePool(PagedPool,
                                  newSize);
      if (newResList == NULL) {
         return STATUS_INSUFFICIENT_RESOURCES;
      }

      newTranslatedResList = ExAllocatePool(PagedPool,
                                            newSize);

      if (newTranslatedResList == NULL) {
         ExFreePool(newResList);
         return STATUS_INSUFFICIENT_RESOURCES;
      }
      newResList->Count = newTranslatedResList->Count = 1;
      newResList->List[0].InterfaceType = resList->List[0].InterfaceType;
      newTranslatedResList->List[0].InterfaceType = translatedResList->List[0].InterfaceType;
      newResList->List[0].BusNumber = resList->List[0].BusNumber;
      newTranslatedResList->List[0].BusNumber = translatedResList->List[0].BusNumber;

      newResList->List[0].PartialResourceList.Version  = resPartialList->Version;
      newResList->List[0].PartialResourceList.Revision = resPartialList->Revision;
      newResList->List[0].PartialResourceList.Count    = resPartialList->Count - 1;

      newTranslatedResList->List[0].PartialResourceList.Version  = translatedResPartialList->Version;
      newTranslatedResList->List[0].PartialResourceList.Revision = translatedResPartialList->Revision;
      newTranslatedResList->List[0].PartialResourceList.Count    = translatedResPartialList->Count - 1;


      resDesc = resPartialList->PartialDescriptors;
      translatedResDesc = translatedResPartialList->PartialDescriptors;
      newResDesc = newResList->List[0].PartialResourceList.PartialDescriptors;
      newTranslatedResDesc = newTranslatedResList->List[0].PartialResourceList.PartialDescriptors;

      if (CardBusExtension(deviceExtension)) {
         //
         // Remove last memory descriptor - which is what we added
         //
         RtlCopyMemory(newResDesc,
                       resDesc,
                       newResList->List[0].PartialResourceList.Count * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));

         RtlCopyMemory(newTranslatedResDesc,
                       translatedResDesc,
                       newTranslatedResList->List[0].PartialResourceList.Count * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));

      } else {
         //
         // Remove the only memory descriptor..
         //
         for (index = 0; index < resPartialList->Count;
             index++, resDesc++, translatedResDesc++, newResDesc++, newTranslatedResDesc++) {
            if (resDesc->Type != CmResourceTypeMemory) {
               *newResDesc = *resDesc;
               *newTranslatedResDesc = *translatedResDesc;
            }
         }
      }

      irpStack->Parameters.StartDevice.AllocatedResources = newResList;
      irpStack->Parameters.StartDevice.AllocatedResourcesTranslated = newTranslatedResList;
   }

   //
   // Send this down to the PDO first
   //

   status = PcmciaIoCallDriverSynchronous(deviceExtension->LowerDevice, Irp);
   *PassedDown = TRUE ;

   //
   // We set this because the completion routine returns
   // STATUS_MORE_PROCESSING_REQUIRED, which means it needs to be completed
   // again.
   //
   *NeedsRecompletion = TRUE ;

   if (deviceExtension->Flags & PCMCIA_FILTER_ADDED_MEMORY) {
      ExFreePool(newResList);
      ExFreePool(newTranslatedResList);
      irpStack->Parameters.StartDevice.AllocatedResources = resList;
      irpStack->Parameters.StartDevice.AllocatedResourcesTranslated = translatedResList;
   }

   if (!NT_SUCCESS(status)) {
      return status;
   }

   //
   // Give the hardware some time to settle after returning from the pdo
   //
   PcmciaWait(256);
   
   //
   // Initialize the hardware
   //

   status = PcmciaStartPcmciaController(Fdo);


   if (NT_SUCCESS(status)) {
      deviceExtension->Flags |= PCMCIA_DEVICE_STARTED;
   }
   //
   // Remember if cardbus cards will be supported for this controller
   //
   if (CardBusExtension(deviceExtension) &&
       !PcmciaAreCardBusCardsSupported(deviceExtension)) {
      deviceExtension->Flags |= PCMCIA_CARDBUS_NOT_SUPPORTED;
   }
   return status;
}





NTSTATUS
PcmciaFdoStopDevice(
   IN  PDEVICE_OBJECT Fdo,
   IN  PIRP           Irp                OPTIONAL,
   OUT BOOLEAN        *PassedDown        OPTIONAL,
   OUT BOOLEAN        *NeedsRecompletion OPTIONAL
   )
/*++

Routine Description:

   IRP_MN_STOP_DEVICE handler for the given pcmcia controller.
   If Irp is present, it'll send it down first to the PDO.
   Unhooks the interrupt/cancels poll timer etc.

Arguments:

   Fdo               - Pointer to functional device object for the pcmcia
                       controller
   Irp               - If present it's the pointer to the stop Irp initiated
                       by PnP
   PassedDown        - Contains FALSE on entry, which means caller must
                       complete or pass down irp based on status. If set
                       to TRUE, Irp may need to be re-completed...
   NeedsRecompletion - ...In which case this parameter will be checked.

                       Note: PassedDown and NeedsCompletion are ignored and
                             optional only if Irp is NULL.

Return value:

   STATUS_SUCCESS    - Pcmcia controller successfully stopped
   Other             - Stop failed

--*/
{
   PFDO_EXTENSION deviceExtension = Fdo->DeviceExtension;
   PSOCKET        socket;
   NTSTATUS       status;

   if (!(deviceExtension->Flags & PCMCIA_DEVICE_STARTED)) {
      //
      // Already stopped
      //
      return STATUS_SUCCESS;
   }
   
   PcmciaFdoDisarmWake(deviceExtension);

   //
   // Disable the interrupt
   //
   if (deviceExtension->PcmciaInterruptObject) {

      for (socket = deviceExtension->SocketList; socket; socket = socket->NextSocket) {
         //
         // Disable the controller interrupts
         //
         (*(socket->SocketFnPtr->PCBEnableDisableCardDetectEvent))(socket, FALSE);
         (*(socket->SocketFnPtr->PCBEnableDisableWakeupEvent))(socket, NULL, FALSE);
         //
         // Apparently IBM ThinkPads like this
         //
         PcmciaWait(PCMCIA_ENABLE_DELAY);
      }
   }

   //
   // the bus driver below us will make us go offline
   //
   deviceExtension->Flags |= PCMCIA_FDO_OFFLINE;

   //
   // clear pending event
   //   
   KeCancelTimer(&deviceExtension->EventTimer);

   //
   // Send this down to the PDO 
   //
   if (ARGUMENT_PRESENT(Irp)) {

      status = PcmciaIoCallDriverSynchronous(deviceExtension->LowerDevice, Irp);

      *PassedDown = TRUE ;
      *NeedsRecompletion = TRUE ;


      if (!NT_SUCCESS(status)) {
         return status;
      }
   }

   if (deviceExtension->Flags & PCMCIA_USE_POLLED_CSC) {
      //
      // cancel the card status change poller
      //
      KeCancelTimer(&deviceExtension->PollTimer);
      deviceExtension->Flags &= ~PCMCIA_USE_POLLED_CSC;
   }

   if (deviceExtension->PcmciaInterruptObject) {
      //
      // unhook the interrupt
      //
      IoDisconnectInterrupt(deviceExtension->PcmciaInterruptObject);
      deviceExtension->PcmciaInterruptObject = NULL;
   }

   //
   // Unmap any i/o space or memory we might have mapped
   //
   if (deviceExtension->Flags & PCMCIA_ATTRIBUTE_MEMORY_MAPPED) {
      MmUnmapIoSpace(deviceExtension->AttributeMemoryBase,
                     deviceExtension->AttributeMemorySize);
      deviceExtension->Flags &= ~PCMCIA_ATTRIBUTE_MEMORY_MAPPED;
      deviceExtension->AttributeMemoryBase = 0;
      deviceExtension->AttributeMemorySize = 0;
   }

   if (deviceExtension->Flags & PCMCIA_SOCKET_REGISTER_BASE_MAPPED) {
      MmUnmapIoSpace(deviceExtension->CardBusSocketRegisterBase,
                     deviceExtension->CardBusSocketRegisterSize);
      deviceExtension->Flags &= ~PCMCIA_SOCKET_REGISTER_BASE_MAPPED;
      deviceExtension->CardBusSocketRegisterBase = 0;
      deviceExtension->CardBusSocketRegisterSize = 0;
   }

   deviceExtension->Flags &= ~PCMCIA_DEVICE_STARTED;
   return STATUS_SUCCESS;
}



NTSTATUS
PcmciaFdoRemoveDevice(
   IN PDEVICE_OBJECT Fdo,
   IN PIRP           Irp
   )
/*++

Routine Description:

   Handles IRP_MN_REMOVE for the pcmcia controller.
   Stops the adapter if it isn't already, sends the IRP
   to the PDO first & cleans up the Fdo for this controller
   and detaches & deletes the device object.

Arguments:

   Fdo   - Pointer to functional device object for the controller
           to be removed

Return value:

   Status

--*/
{
   PFDO_EXTENSION fdoExtension = Fdo->DeviceExtension;
   PDEVICE_OBJECT pdo, nextPdo, fdo, prevFdo;
   PPDO_EXTENSION pdoExtension;
   NTSTATUS       status;

   UNREFERENCED_PARAMETER(Irp);

   if (fdoExtension->Flags & PCMCIA_DEVICE_STARTED) {
      //
      // Stop the fdo first.
      //
      PcmciaFdoStopDevice(Fdo, NULL, NULL, NULL);
   }

   //
   // Send this down to the PDO
   //

   status = PcmciaIoCallDriverSynchronous(fdoExtension->LowerDevice, Irp);

   if (!NT_SUCCESS(status)) {
      return status;
   }

   //
   // If the PdoList in the fdoExtension is non-empty it means:
   // that the PDOs in the list were not physically removed, but
   // a soft REMOVE was issued, hence they are still hanging on
   // and now this controller itself is being REMOVED.
   // Hence we dispose of those PDOs now
   //

   for (pdo = fdoExtension->PdoList; pdo != NULL ; pdo = nextPdo) {
      DebugPrint((PCMCIA_DEBUG_INFO,
                  "RemoveDevice: pdo %x child of fdo %x was not removed before fdo\n",
                  pdo, Fdo));

      pdoExtension = pdo->DeviceExtension;

      ASSERT (!IsDevicePhysicallyRemoved(pdoExtension));
      //
      // It's possible for this bit to be on, if the device was added,
      // but never started (because of some other error.
      //ASSERT (!IsDeviceAlive(pdoExtension));

      nextPdo =  pdoExtension->NextPdoInFdoChain;
      if (!IsDeviceDeleted(pdoExtension)) {
         MarkDeviceDeleted(pdoExtension);
         PcmciaCleanupPdo(pdo);
         IoDeleteDevice(pdo);
      }
   }

   MarkDeviceDeleted(fdoExtension);
   PcmciaCleanupFdo(fdoExtension);

   //
   // Remove this from the fdo list..
   //
   prevFdo = NULL;
   for (fdo = FdoList; fdo != NULL; prevFdo = fdo, fdo = fdoExtension->NextFdo) {
      fdoExtension = fdo->DeviceExtension;
      if (fdo == Fdo) {
         if (prevFdo) {
            //
            // Delink this fdo
            //
            ((PFDO_EXTENSION)prevFdo->DeviceExtension)->NextFdo
            = fdoExtension->NextFdo;
         } else {
            FdoList = fdoExtension->NextFdo;
         }
         break;
      }
   }

   DebugPrint((PCMCIA_DEBUG_PNP, "fdo %08x Remove detach & delete\n", Fdo));
   IoDetachDevice(((PFDO_EXTENSION)Fdo->DeviceExtension)->LowerDevice);
   IoDeleteDevice(Fdo);

   return STATUS_SUCCESS;
}



VOID
PcmciaCleanupContext(
   IN PPCMCIA_CONTEXT pContext
   )
/*++

Routine Description

   Frees up allocated pool associated with a specific controller
   register context.

Arguments

   pContext - pointer to a PCMCIA_CONTEXT structure

Return value

   none

--*/
{
   pContext->RangeCount = 0;

   if (pContext->Range) {
      ExFreePool(pContext->Range);
      pContext->Range = NULL;
   }
}



VOID
PcmciaCleanupFdo(
   IN PFDO_EXTENSION FdoExtension
   )
/*++

Routine Description

   Frees up allocated pool, deletes symbolic links etc. for the
   associated FDO for the pcmcia controller which is to be removed.

Arguments

   FdoExtension   - Pointer to the device extension for the FDO of the pcmcia controller
                    which is being removed

Return value

   none

--*/
{
   PSOCKET        socket, nextSocket;

   //
   // Free the controller register context
   //
   PcmciaCleanupContext(&FdoExtension->PciContext);
   if (FdoExtension->PciContextBuffer) {
      ExFreePool(FdoExtension->PciContextBuffer);
      FdoExtension->PciContextBuffer = NULL;
   }

   PcmciaCleanupContext(&FdoExtension->CardbusContext);
   PcmciaCleanupContext(&FdoExtension->ExcaContext);

   //
   // Delete symbolic links to this fdo
   //
   if (FdoExtension->LinkName.Buffer != NULL) {
      IoDeleteSymbolicLink(&FdoExtension->LinkName);
      RtlFreeUnicodeString(&FdoExtension->LinkName);
   }

   //
   // Cleanup the socket structures
   //
   for (socket = FdoExtension->SocketList; socket != NULL; socket = nextSocket) {

      if (socket->CardbusContextBuffer) {
         ExFreePool(socket->CardbusContextBuffer);
         socket->CardbusContextBuffer = NULL;
      }

      if (socket->ExcaContextBuffer) {
         ExFreePool(socket->ExcaContextBuffer);
         socket->ExcaContextBuffer = NULL;
      }

      nextSocket = socket->NextSocket;
      ExFreePool(socket);
   }

   FdoExtension->SocketList = NULL;
   return;
}



NTSTATUS
PcmciaFdoGetAssignedResources(
   IN PCM_RESOURCE_LIST ResourceList,
   IN PCM_RESOURCE_LIST TranslatedResourceList,
   IN PFDO_EXTENSION    DeviceExtension
   )
/*++

Routine Description:

   Extracts the assigned resources to the pcmcia controller

Arguments:

   ResourceList            - Raw resource list
   TranslatedResourceList
   DeviceExtension         - Device extension of the PCMCIA controller

Return value:

   STATUS_SUCCESS
   STATUS_UNSUCCESSFUL      if resources are not right or enough.

--*/
{
   PCM_FULL_RESOURCE_DESCRIPTOR     fullResourceDesc;
   PCM_PARTIAL_RESOURCE_LIST        partialResourceList;
   PCM_PARTIAL_RESOURCE_DESCRIPTOR  partialResourceDesc;
   ULONG                            addressSpace;
   PHYSICAL_ADDRESS                 physicalAddress;
   PHYSICAL_ADDRESS                 translatedAddress;
   ULONG i;
   ULONG attributeIndex;
   PULONG                           devicePrivate;
   BOOLEAN                          translated;

   PAGED_CODE();


   if ((ResourceList == NULL) || (ResourceList->Count <=0) ) {
      return STATUS_UNSUCCESSFUL;
   }


   if (CardBusExtension(DeviceExtension)) {

      fullResourceDesc=&TranslatedResourceList->List[0];
      DeviceExtension->Configuration.InterfaceType = fullResourceDesc->InterfaceType;
      DeviceExtension->Configuration.BusNumber = fullResourceDesc->BusNumber;

      partialResourceList = &fullResourceDesc->PartialResourceList;
      partialResourceDesc = partialResourceList->PartialDescriptors;
      //
      // We need just the exca register base
      // According to PeterJ the first descriptor
      // for us is the cardbus socket register base.
      // We trust him.
      for (i=0; (i < partialResourceList->Count) && (partialResourceDesc->Type != CmResourceTypeMemory);
          i++, partialResourceDesc++);
      if (i >= partialResourceList->Count) {
         return STATUS_UNSUCCESSFUL;
      };

      //
      // This is memory. We need to map it
      //
      DeviceExtension->CardBusSocketRegisterBase = MmMapIoSpace(partialResourceDesc->u.Memory.Start,
                                                                partialResourceDesc->u.Memory.Length,
                                                                FALSE);
      DeviceExtension->CardBusSocketRegisterSize = partialResourceDesc->u.Memory.Length;

      DeviceExtension->Flags |= PCMCIA_SOCKET_REGISTER_BASE_MAPPED;

      //
      // Last BAR is attribute memory window. This will be peeled off later.
      // It might be a good idea to tack a device private on at the end to
      // confirm this. However how do we guarantee our device private does
      // not contain the same data as somebody else's? PnP is lacking here -
      // we need some convention so that devices can set uniquely identifying stuff
      // in there - like maybe the device object they own - to identify it is
      // theirs. Till then this should do.
      //
      if (i > (partialResourceList->Count - 2)) {
         //
         // No more resources? Bail out.
         //
         return STATUS_INSUFFICIENT_RESOURCES;
      }

      for (i++, partialResourceDesc++; (i < (partialResourceList->Count - 1));i++,partialResourceDesc++);
      //
      // partialResourceDesc points to the last descriptor
      //
      ASSERT (partialResourceDesc->Type == CmResourceTypeMemory);
      DeviceExtension->PhysicalBase = partialResourceDesc->u.Memory.Start;
      //
      // This is memory. We need to map it
      //
      DeviceExtension->AttributeMemoryBase = MmMapIoSpace(partialResourceDesc->u.Memory.Start,
                                                          partialResourceDesc->u.Memory.Length,
                                                          FALSE);
      DeviceExtension->AttributeMemorySize = partialResourceDesc->u.Memory.Length;
      DeviceExtension->Flags |= PCMCIA_ATTRIBUTE_MEMORY_MAPPED;

      //
      // Finally see if an IRQ is assigned
      //

      for (i = 0, partialResourceDesc = partialResourceList->PartialDescriptors;
          (i < partialResourceList->Count) && (partialResourceDesc->Type != CmResourceTypeInterrupt);
          i++,partialResourceDesc++);


      if (i < partialResourceList->Count) {
         //
         // We have an interrupt to used for CSC
         // PCI will ensure that this interrupt is exactly the
         // same as the one assigned to the functional interrupt
         // for a cardbus pc-card in this controller's socket
         //
         DebugPrint((PCMCIA_DEBUG_INFO, "PcmciaGetAssignedResources: Interrupt resource assigned\n"));
         DeviceExtension->Configuration.TranslatedInterrupt = *partialResourceDesc;
         //
         // Get the raw interrupt resource  - needed to enable the interrupt on the controller
         //
         fullResourceDesc=&ResourceList->List[0];
         partialResourceList = &fullResourceDesc->PartialResourceList;
         partialResourceDesc = partialResourceList->PartialDescriptors;
         for (i=0; (i< partialResourceList->Count) && (partialResourceDesc->Type != CmResourceTypeInterrupt);
             i++, partialResourceDesc++);
         if (i < partialResourceList->Count) {
            DeviceExtension->Configuration.Interrupt = *partialResourceDesc;
         } else {
            //
            // Should not happen.. translated descriptor was present, but raw is missing!
            // Just reset the translated interrupt and pretend no interrupt was assigned
            //
            RtlZeroMemory(&DeviceExtension->Configuration.TranslatedInterrupt, sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));
         }
      }
   } else {
      //
      // 16-bit pcmcia controller
      //
      fullResourceDesc=&ResourceList->List[0];
      DeviceExtension->Configuration.InterfaceType = fullResourceDesc->InterfaceType;
      DeviceExtension->Configuration.BusNumber = fullResourceDesc->BusNumber;

      partialResourceList = &fullResourceDesc->PartialResourceList;
      partialResourceDesc = partialResourceList->PartialDescriptors;

      for (i=0; i<partialResourceList->Count; i++, partialResourceDesc++) {

         devicePrivate = partialResourceDesc->u.DevicePrivate.Data;

         switch (partialResourceDesc->Type) {

         case CmResourceTypeInterrupt: {
               if (DeviceExtension->ControllerType != PcmciaCLPD6729 &&
                   DeviceExtension->ControllerType != PcmciaPciPcmciaBridge &&
                   DeviceExtension->ControllerType != PcmciaNEC98 &&
                   DeviceExtension->ControllerType != PcmciaNEC98102) {

                  // We always poll for Cirrus Logic PCI to PCMCIA  controllers
                  // and other PCI-PCMCIA bridges
                  //

                  DeviceExtension->Configuration.Interrupt = *partialResourceDesc;
               }
               break;
            }
         case CmResourceTypePort: {
               DeviceExtension->Configuration.UntranslatedPortAddress = (USHORT) partialResourceDesc->u.Port.Start.QuadPart;
               DeviceExtension->Configuration.PortSize = (USHORT) partialResourceDesc->u.Port.Length;
               break;
            }
         case CmResourceTypeMemory: {
               DeviceExtension->PhysicalBase =         partialResourceDesc->u.Memory.Start;
               DeviceExtension->AttributeMemorySize =  partialResourceDesc->u.Memory.Length;
               attributeIndex = i;
               break;
            }
         }
      }

      if ((DeviceExtension->PhysicalBase.QuadPart == 0) ||
          (DeviceExtension->Configuration.UntranslatedPortAddress == 0)) {

         DebugPrint((PCMCIA_DEBUG_FAIL, "PcmciaGetAssignedResources: Need both memory and i/o for pcmcia controller 0x%X\n",
                     DeviceExtension->DeviceObject));
         return STATUS_INSUFFICIENT_RESOURCES;
      }


      fullResourceDesc=&TranslatedResourceList->List[0];
      partialResourceList = &fullResourceDesc->PartialResourceList;
      partialResourceDesc = &partialResourceList->PartialDescriptors[attributeIndex];


      switch (partialResourceDesc->Type) {

      case CmResourceTypeMemory:
         DeviceExtension->AttributeMemoryBase = MmMapIoSpace(partialResourceDesc->u.Memory.Start,
                                                             DeviceExtension->AttributeMemorySize,
                                                             FALSE);
         DeviceExtension->Flags |= PCMCIA_ATTRIBUTE_MEMORY_MAPPED;
         break;

      case CmResourceTypePort:
         DeviceExtension->AttributeMemoryBase = (PUCHAR)(partialResourceDesc->u.Port.Start.QuadPart);
         DeviceExtension->Flags &= ~PCMCIA_ATTRIBUTE_MEMORY_MAPPED;
         break;

      default:
         ASSERT(FALSE);
         return STATUS_INSUFFICIENT_RESOURCES;
      }

   }
   return STATUS_SUCCESS;
}



NTSTATUS
PcmciaAreCardBusCardsSupported(
   IN PFDO_EXTENSION FdoExtension
   )
/*++

Routine Description:

    Indicates if cardbus cards will be supported on the given PCMCIA
    controller on this system
    Currently we support cardbus cards only on:
       Machines on which BIOS programmed the bus numbers & IntLine

Arguments:

    FdoExtension - Pointer to device extension for the pcmcia controller

Return Value:

    TRUE  - if cardbus cards are supported
    FALSE - if not

--*/
{
    UCHAR             byte;

    PAGED_CODE();

    //
    // Check int line
    //
    GetPciConfigSpace(FdoExtension,
                      CFGSPACE_INT_LINE,
                      &byte,
                      1);
    if (byte == 0xff) {
         return FALSE;
    }

    //
    // Check  cardbus bus number
    //
    GetPciConfigSpace(FdoExtension,
                      CFGSPACE_CARDBUS_BUSNUM,
                      &byte,
                      1);
    if (byte == 0) {
         return FALSE;
    }

    //
    // Check subordinate bus number
    //
    GetPciConfigSpace(FdoExtension,
                      CFGSPACE_SUB_BUSNUM,
                      &byte,
                      1);
    if (byte == 0) {
         return FALSE;
    }

    //
    // All tests passed
    //
    return TRUE;
}