/*++

Copyright (c) 1997-2000 Microsoft Corporation

Module Name:

    pdocb.c

Abstract:

    This module contains the code to handle
    the IRP_MJ_PNP dispatches for the PDOs
    for cardbus devices

Authors:

    Ravisankar Pudipeddi (ravisp)
    Neil Sandlin (neilsa) 1-Jun-1999

Environment:

    Kernel mode only

Notes:

Revision History:

--*/

#include "pch.h"

//
// Internal References
//

NTSTATUS
PcmciaStartCardBusCard(
   IN PDEVICE_OBJECT Pdo,
   IN OUT PIRP       Irp
   );
   
NTSTATUS
PcmciaRemoveCardBusCard(
   IN PDEVICE_OBJECT Pdo,
   IN PIRP           Irp
   );

NTSTATUS
PcmciaQueryCardBusCardResourceRequirements(
   IN PDEVICE_OBJECT Pdo,
   IN PIRP           Irp
   );
   
NTSTATUS
PcmciaQueryCardBusCardCapabilities(
   IN PDEVICE_OBJECT Pdo,
   IN PIRP           Irp
   );
   

#ifdef ALLOC_PRAGMA
   #pragma alloc_text(PAGE,  PcmciaPdoCardBusPnPDispatch)
   #pragma alloc_text(PAGE,  PcmciaStartCardBusCard)
   #pragma alloc_text(PAGE,  PcmciaRemoveCardBusCard)
   #pragma alloc_text(PAGE,  PcmciaQueryCardBusCardResourceRequirements)
   #pragma alloc_text(PAGE,  PcmciaQueryCardBusCardCapabilities)
#endif



NTSTATUS
PcmciaPdoCardBusPnPDispatch(
   IN PDEVICE_OBJECT Pdo,
   IN PIRP Irp
   )

/*++

Routine Description:

    This routine handles pnp requests for the filter object for CardBus devices.

Arguments:

    Pdo - pointer to the physical device object
    Irp - pointer to the io request packet

Return Value:

    status

--*/

{
   PPDO_EXTENSION pdoExtension = Pdo->DeviceExtension;
   PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
   NTSTATUS status = STATUS_NOT_SUPPORTED;

   PAGED_CODE();
   ASSERT (pdoExtension->LowerDevice);

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

   //
   // CardBus PnP Dispatch
   //

   switch (irpStack->MinorFunction) {
   
   case IRP_MN_START_DEVICE:
      status = PcmciaStartCardBusCard(Pdo, Irp);
      PcmciaDoStartSound(pdoExtension->Socket, status);
      break;
      
   case IRP_MN_REMOVE_DEVICE: 
      status = PcmciaRemoveCardBusCard(Pdo, Irp);
      break;
      
   case IRP_MN_STOP_DEVICE:
      PcmciaSkipCallLowerDriver(status, pdoExtension->LowerDevice, Irp);
      MarkDeviceNotStarted(pdoExtension);
      break;
      
   case IRP_MN_SURPRISE_REMOVAL:
      if (IsDevicePhysicallyRemoved(pdoExtension)) {
         PcmciaSetSocketPower(pdoExtension->Socket, NULL, NULL, PCMCIA_POWEROFF);      
      }         
      PcmciaSkipCallLowerDriver(status, pdoExtension->LowerDevice, Irp);
      break;

   case IRP_MN_QUERY_RESOURCE_REQUIREMENTS: 
      status = PcmciaQueryCardBusCardResourceRequirements(Pdo, Irp);
      break;                                                     
                                                  
   case IRP_MN_QUERY_CAPABILITIES: 
      status = PcmciaQueryCardBusCardCapabilities(Pdo, Irp);
      break;
      
   case IRP_MN_QUERY_INTERFACE: 
      status = PcmciaPdoQueryInterface(Pdo, Irp);
      break;
      
   default:
      PcmciaSkipCallLowerDriver(status, pdoExtension->LowerDevice, Irp);
   }

   DebugPrint((PCMCIA_DEBUG_PNP, "pdo %08x irp %08x <-- %s %08x\n", Pdo, Irp,
                                  STATUS_STRING(status), status));

   return status;
}



NTSTATUS
PcmciaStartCardBusCard(
   IN PDEVICE_OBJECT Pdo,
   IN OUT PIRP       Irp
   )
/*++

Routine Description:

   This routine attempts to start the PC-Card by configuring it with the supplied resources.


Arguments:

   Pdo - Pointer to the device object representing the PC-Card which needs to be started
   ResourceList - Pointer the list of assigned resources for the PC-Card

Return value:

   STATUS_INSUFFICIENT_RESOURCES - Not sufficient resources supplied to start device/
                                   could not allocate memory
   STATUS_UNSUCCESSFUL           - Supplied resources are invalid for this PC-Card
   STATUS_SUCCESS                - Configured and started the card successfully

--*/
{
   PPDO_EXTENSION pdoExtension = Pdo->DeviceExtension;
   PSOCKET        socket = pdoExtension->Socket;
   PSOCKET_DATA   socketData = pdoExtension->SocketData;
   PFDO_EXTENSION fdoExtension = socket->DeviceExtension;
   USHORT         word;
   UCHAR          BaseClass;
   NTSTATUS       status = STATUS_NOT_SUPPORTED;
   ULONG          i;
   ULONG          devid;
   USHORT         cls_lat;
   BOOLEAN        setAudio = FALSE;
   
   PAGED_CODE();

   ASSERT (pdoExtension->LowerDevice);

   //
   // Apply some hacks if necessary
   //
   status = PcmciaConfigureCardBusCard(pdoExtension);

   if (!NT_SUCCESS(status)) {
      //
      // The card's config space probably never became visible
      //
      Irp->IoStatus.Status = status;
      IoCompleteRequest(Irp, IO_NO_INCREMENT);
      return status;
   }
   
   //
   // Select PCI IRQ routing
   //
   
   CBEnableDeviceInterruptRouting(socket);

   //
   // Turn on ZV for this card, if it needs it
   // 
   if (socketData && (socketData->Flags & SDF_ZV)) {
      if (PcmciaSetZV(fdoExtension, socket, TRUE)) {
         SetSocketFlag(socket, SOCKET_CUSTOM_INTERFACE);
      }
   } else if (IsSocketFlagSet(socket, SOCKET_CUSTOM_INTERFACE)) {
      PcmciaSetZV(fdoExtension, socket, FALSE);
      ResetSocketFlag(socket, SOCKET_CUSTOM_INTERFACE);
   }

   //
   // Pci needs to enable this card .. send it down to the PDO
   //

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

   //
   // Apparently cardbus modems aren't immune to needing delays
   // This yield duration was emperically determined using the Xircom RBM56G
   //
   GetPciConfigSpace(pdoExtension, CFGSPACE_CLASSCODE_BASECLASS, &BaseClass, 1);
   if (BaseClass == PCI_CLASS_SIMPLE_COMMS_CTLR) {
      //
      // Wait for modem to warm up
      //
      PcmciaWait(CBModemReadyDelay);
      setAudio = TRUE;
   }      
   
   PcmciaSetAudio(fdoExtension, socket, setAudio);   
   
   //
   // Assume that the cardbus controller has the correct CLS and latency
   // timer values, and that the cardbus device has zeroes.
   //
   
   GetPciConfigSpace(fdoExtension, CFGSPACE_CACHE_LINESIZE, &cls_lat, sizeof(cls_lat));
   SetPciConfigSpace(pdoExtension, CFGSPACE_CACHE_LINESIZE, &cls_lat, sizeof(cls_lat));

   if (NT_SUCCESS(status)) {
      MarkDeviceStarted(pdoExtension);
      MarkDeviceLogicallyInserted(pdoExtension);
   }
   
   Irp->IoStatus.Status = status;
   IoCompleteRequest(Irp, IO_NO_INCREMENT);
   return status;
}



NTSTATUS
PcmciaRemoveCardBusCard(
   IN PDEVICE_OBJECT Pdo,
   IN PIRP           Irp
   )
/*++

Routine Description:

Arguments:

Return value:

--*/
{
   PPDO_EXTENSION pdoExtension = Pdo->DeviceExtension;
   PSOCKET        socket = pdoExtension->Socket;
   NTSTATUS status;

   ASSERT(socket != NULL);

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

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

   if (!NT_SUCCESS(status)) {
      Irp->IoStatus.Status = status;
      IoCompleteRequest(Irp, IO_NO_INCREMENT);
      return status;
   }      

   if (IsDevicePhysicallyRemoved(pdoExtension)) {
      PFDO_EXTENSION fdoExtension = socket->DeviceExtension;
      PDEVICE_OBJECT curPdo, prevPdo;
      PPDO_EXTENSION curPdoExt;
      ULONG waitCount = 0;
      
      //
      // Synchronize with power routines
      // LATER: make these values adjustable
      //     
      while(!PCMCIA_TEST_AND_SET(&pdoExtension->DeletionLock)) {
         PcmciaWait(1000000);
         if (waitCount++ > 20) {
            ASSERT(waitCount <= 20);
            break;
         }
      }
   
      //
      // Delink this Pdo from the FDO list.
      //
      for (curPdo = fdoExtension->PdoList, prevPdo = NULL; curPdo!=NULL; prevPdo=curPdo, curPdo=curPdoExt->NextPdoInFdoChain) {
         curPdoExt = curPdo->DeviceExtension;
         
         if (curPdo == Pdo) {
            if (prevPdo) {
               ((PPDO_EXTENSION)prevPdo->DeviceExtension)->NextPdoInFdoChain = pdoExtension->NextPdoInFdoChain;
            } else {
               fdoExtension->PdoList = pdoExtension->NextPdoInFdoChain;
            }
            break;
         }
      }
      
      //
      // Delink this Pdo from the socket list.
      //
      for (curPdo = socket->PdoList, prevPdo = NULL; curPdo!=NULL; prevPdo=curPdo, curPdo=curPdoExt->NextPdoInSocket) {
         curPdoExt = curPdo->DeviceExtension;
         
         if (curPdo == Pdo) {
            if (prevPdo) {
               ((PPDO_EXTENSION)prevPdo->DeviceExtension)->NextPdoInSocket = pdoExtension->NextPdoInSocket;
            } else {
               socket->PdoList = pdoExtension->NextPdoInSocket;
            }
            break;
         }
      }
   
      PcmciaCleanupPdo(Pdo);
      //
      // Delete..
      //
      if (!IsDeviceDeleted(pdoExtension)) {
         MarkDeviceDeleted(pdoExtension);
         IoDeleteDevice(Pdo);
      }
   
   
      PcmciaSetSocketPower(pdoExtension->Socket, NULL, NULL, PCMCIA_POWEROFF);      
      
      if (--fdoExtension->PciAddCardBusCount == 0) {
         ResetSocketFlag(socket, SOCKET_CLEANUP_PENDING);
         //
         // If a query_device_relations came in after a card was inserted, but before
         // we have removed the previous card configuration, the enumeration would have been
         // postponed. Here, we start it up again
         //
         if (IsSocketFlagSet(socket, SOCKET_ENUMERATE_PENDING)) {
            ResetSocketFlag(socket, SOCKET_ENUMERATE_PENDING);
            SetSocketFlag(socket, SOCKET_CARD_STATUS_CHANGE);
            IoInvalidateDeviceRelations(fdoExtension->Pdo, BusRelations);
         }
      } 
   
   } else {
      //
      // We will keep this Pdo around, since this is not physically ejected.
      //
      MarkDeviceLogicallyRemoved(pdoExtension);
   }
   
   
   Irp->IoStatus.Status = status;
   IoCompleteRequest(Irp, IO_NO_INCREMENT);
   return status;
}



NTSTATUS
PcmciaQueryCardBusCardResourceRequirements(
   IN PDEVICE_OBJECT Pdo,
   IN PIRP           Irp
   )
/*++

Routine Description:

   This routine filters the interrupt requirement generated by pci for the cardbus
   card to restrict it to the parent controller's vector. This is anyway what has to
   happen, and this way, the card will still get the interrupt even if there is no
   irq routing on the machine.

Arguments:

   Pdo - Pointer to the device object representing the PC-Card which needs to be started
   Irp - IRP_MN_QUERY_RESOURCE_REQUIREMENTS Irp

Return value:

   status

--*/
{
   PPDO_EXTENSION pdoExtension = Pdo->DeviceExtension;
   PFDO_EXTENSION fdoExtension = pdoExtension->Socket->DeviceExtension;
   NTSTATUS       status;
   ULONG          index1, index2;
   PIO_RESOURCE_REQUIREMENTS_LIST IoReqList;
   PIO_RESOURCE_LIST   ioResourceList;
   PIO_RESOURCE_DESCRIPTOR ioResourceDesc;
   
   PAGED_CODE();

   PcmciaUpdateInterruptLine(pdoExtension, fdoExtension);
   //
   // First pass the irp down the stack 
   //
   status = PcmciaIoCallDriverSynchronous(pdoExtension->LowerDevice, Irp);

   IoReqList = (PIO_RESOURCE_REQUIREMENTS_LIST) Irp->IoStatus.Information;
   
   if (!NT_SUCCESS(status) ||
       (IoReqList == NULL) ||
       (fdoExtension->Configuration.Interrupt.u.Interrupt.Vector == 0)) {
      IoCompleteRequest(Irp, IO_NO_INCREMENT);
      return status;
   }

   //
   // Change interrupt descriptors to specifically request the parent vector
   //
   for (index1 = 0, ioResourceList = IoReqList->List;
       index1 < IoReqList->AlternativeLists; index1++) {
      ioResourceDesc = ioResourceList->Descriptors;
      
      for (index2 = 0 ; index2 < ioResourceList->Count; index2++, ioResourceDesc++) {
         if (ioResourceDesc->Type == CmResourceTypeInterrupt) {
            //
            // Cardbus cards by design use the same irq as the parent bus controller
            //         
            ioResourceDesc->u.Interrupt.MinimumVector = fdoExtension->Configuration.Interrupt.u.Interrupt.Vector;
            ioResourceDesc->u.Interrupt.MaximumVector = fdoExtension->Configuration.Interrupt.u.Interrupt.Vector;
         }
      }

      ioResourceList = (PIO_RESOURCE_LIST) (((PUCHAR) ioResourceList) +
                                            sizeof(IO_RESOURCE_LIST) +
                                            (ioResourceList->Count - 1)* sizeof(IO_RESOURCE_DESCRIPTOR));
   } // outer for loop
   
   Irp->IoStatus.Status = status;
   IoCompleteRequest(Irp, IO_NO_INCREMENT);
   return status;
}   



NTSTATUS
PcmciaQueryCardBusCardCapabilities(
   IN PDEVICE_OBJECT Pdo,
   IN PIRP           Irp
   )
/*++

Routine Description:

   Obtains the device capabilities of the given pc-card.

   If the pc-card is an R2 card (16-bit pc-card), the capabilities
   are constructed from the parent PCMCIA controller's capabilities.
   If it's a cardbus card, the capabilities are obtained from the underlying
   PCI pdo for the card.
   Finally the obtained capabilities are cached in the pc-card's device
   extension for use in power management of the card.

Arguments:

   Pdo   -    Pointer to the device object for the pc-card
   Irp   -    Pointer to the query device capabilities Irp

Return Value:

   STATUS_SUCCESS                   - Capabilities obtained and recorded in the passed in pointer
   STATUS_INSUFFICIENT_RESOURCES    - Could not allocate memory to cache the capabilities

--*/
{
   PPDO_EXTENSION pdoExtension = Pdo->DeviceExtension;
   NTSTATUS status;

   PAGED_CODE();

   //
   // CardBus card. Get the capabilities from PCI
   //

   status = PcmciaIoCallDriverSynchronous(pdoExtension->LowerDevice, Irp);
   
   if (NT_SUCCESS(status)) {
      PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
      PDEVICE_CAPABILITIES capabilities = irpStack->Parameters.DeviceCapabilities.Capabilities;
      
      //
      // Filter the capabilities: we need to set Removable true
      // since this is a pc-card (PCI doesn't know the difference)
      //
      capabilities->Removable = TRUE;
//********************************
// NOTE: HACKHACK
// This is temporary code only to get cardbus wake-on-lan up and running. Here
// we check to see if this has only been marked as a "can't wake" device by
// pci because it said it could wake from D3Hot, but not from D3Cold.
//********************************

      if (capabilities->DeviceWake <= PowerDeviceD0) {
         UCHAR capptr;
         ULONG powercaps;
     
         GetPciConfigSpace(pdoExtension, CBCFG_CAPPTR, &capptr, sizeof(capptr));
         if (capptr) {
            GetPciConfigSpace(pdoExtension, capptr, &powercaps, sizeof(powercaps));
           
            if (((powercaps & 0xff) == 1) && ((powercaps&0x40000000) && !(powercaps&0x80000000))) {
               capabilities->DeviceWake = PowerDeviceD3;
               capabilities->SystemWake = PowerSystemSleeping3;
               capabilities->WakeFromD3 = 1;
            }
         }
      }

      if (capabilities->SystemWake > PowerSystemSleeping3) {
         capabilities->SystemWake = PowerSystemSleeping3;
      }
//********************************
// END HACK
//********************************   
      
      //
      // Store these capabilities away..
      //
      RtlCopyMemory(&pdoExtension->DeviceCapabilities,
                    capabilities,
                    sizeof(DEVICE_CAPABILITIES));
   } else {
   
      RtlZeroMemory(&pdoExtension->DeviceCapabilities, sizeof(DEVICE_CAPABILITIES));   
      
   }

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