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

/*++

Copyright (c) 1997-2000 Microsoft Corporation

Module Name:

    pcmcia.c

Abstract:

    This module contains the code that controls the PCMCIA slots.

Author:

    Bob Rinne (BobRi) 3-Aug-1994
    Jeff McLeman 12-Apr-1994
    Ravisankar Pudipeddi (ravisp) 1-Nov-96
    Neil Sandlin (neilsa) 1-Jun-1999

Environment:

    Kernel mode

Revision History :
    6-Apr-95
          Modified for databook support - John Keys Databook
    1-Nov-96
          Total overhaul to make this a bus enumerator - Ravisankar Pudipeddi (ravisp)


--*/

#include "pch.h"

//
// Internal References
//

NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath
    );

VOID
PcmciaUnload(
    IN PDRIVER_OBJECT DriverObject
    );

#ifdef ALLOC_PRAGMA
    #pragma alloc_text(INIT,DriverEntry)
    #pragma alloc_text(PAGE, PcmciaUnload)
    #pragma alloc_text(PAGE, PcmciaOpenCloseDispatch)
    #pragma alloc_text(PAGE, PcmciaCleanupDispatch)
    #pragma alloc_text(PAGE, PcmciaFdoSystemControl)
    #pragma alloc_text(PAGE, PcmciaPdoSystemControl)
#endif

PUNICODE_STRING  DriverRegistryPath;



NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath
    )

/*++

Routine Description:

    The entry point that the system point calls to initialize
    any driver.
    Since this is a plug'n'play driver, we should return after setting
    the entry points & initializing our dispatch table.
    Currently we also detect our own PCMCIA controllers and report
    them - which should not be needed in the future when a root bus
    driver such as PCI or ISAPNP will locate the controllers for us.

Arguments:

    DriverObject - Pointer to object representing this driver

    RegistryPath - Pointer the the registry key for this driver
                        under \CurrentControlSet\Services

Return Value:


--*/

{
    NTSTATUS                      status = STATUS_SUCCESS;
    ULONG                         i;

    PAGED_CODE();

    DebugPrint((PCMCIA_DEBUG_INFO,"Initializing Driver\n"));

    //
    // Load in common parameters from the registry
    //
    status = PcmciaLoadGlobalRegistryValues();
    if (!NT_SUCCESS(status)) {
        return status;
    }

    //
    //
    // Set up the device driver entry points.
    //

    DriverObject->DriverExtension->AddDevice = PcmciaAddDevice;

    DriverObject->DriverUnload = PcmciaUnload;
    //
    //
    // Save our registry path
    DriverRegistryPath = RegistryPath;

    //
    // Initialize the event used by the delay execution
    // routine.
    //
    KeInitializeEvent(&PcmciaDelayTimerEvent,
                      NotificationEvent,
                      FALSE);

    //
    // Initialize global lock
    //
    KeInitializeSpinLock(&PcmciaGlobalLock);

    //
    // Init device dispatch table
    //
    PcmciaInitDeviceDispatchTable(DriverObject);

    //
    // Locate PCMCIA controllers and report them - this
    // is temporary - till the detection for these
    // controllers is moved into
    // appropriate root bus driver such as the PCI bus driver..

    //   if (PcmciaLegacyDetectionOk()) {
    status = PcmciaDetectPcmciaControllers(DriverObject,RegistryPath);
    // }

    //
    // Ignore the status. Regardless of whether we found controllers or not
    // we need to stick around since we might get an AddDevice non-legacy
    // controllers
    //
    return STATUS_SUCCESS;
}



NTSTATUS
PcmciaOpenCloseDispatch(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

     Open or Close device routine

Arguments:

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

Return Value:

     Status

--*/

{
    NTSTATUS status;

    PAGED_CODE();

    DebugPrint((PCMCIA_DEBUG_INFO, "PCMCIA: Open / close of Pcmcia controller for IO \n"));

    status = STATUS_SUCCESS;

    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, 0);
    return status;
}



NTSTATUS
PcmciaCleanupDispatch(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

     Handles IRP_MJ_CLEANUP

Arguments:

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

Return Value:

     Status

--*/

{
    NTSTATUS status;

    PAGED_CODE();

    DebugPrint((PCMCIA_DEBUG_INFO, "PCMCIA: Cleanup of Pcmcia controller for IO \n"));
    status = STATUS_SUCCESS;

    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, 0);
    return status;
}



NTSTATUS
PcmciaFdoSystemControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

     Handles IRP_MJ_SYSTEM_CONTROL

Arguments:

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

Return Value:

     Status

--*/

{
    PFDO_EXTENSION fdoExtension = DeviceObject->DeviceExtension;

    PAGED_CODE();

    IoSkipCurrentIrpStackLocation(Irp);
    return IoCallDriver(fdoExtension->LowerDevice, Irp);
}



NTSTATUS
PcmciaPdoSystemControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

     Handles IRP_MJ_SYSTEM_CONTROL

Arguments:

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

Return Value:

     Status

--*/

{
    NTSTATUS status;
    PPDO_EXTENSION pdoExtension = DeviceObject->DeviceExtension;

    PAGED_CODE();

    if (IsCardBusCard(pdoExtension)) {
        //
        // Pass irp down the stack for cardbus cards
        //
        IoSkipCurrentIrpStackLocation(Irp);
        status = IoCallDriver(pdoExtension->LowerDevice, Irp);
    } else {
        //
        // Complete the irp for R2 cards
        //
        status = Irp->IoStatus.Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
    return status;
}



VOID
PcmciaUnload(
    IN PDRIVER_OBJECT DriverObject
    )

/*++

Description:

     Unloads the driver after cleaning up

Arguments:

     DriverObject -- THe device drivers object

Return Value:

     None

--*/

{
    PDEVICE_OBJECT  fdo, pdo, nextFdo, nextPdo;
    PFDO_EXTENSION  fdoExtension;
    PSOCKET             socket, nextSocket;
    PPCMCIA_NTDETECT_DATA pData, pNextData;

    PAGED_CODE();

    DebugPrint((PCMCIA_DEBUG_INFO, "PcmciaUnload Entered\n"));

    pData = pNtDetectDataList;
    while(pData != NULL) {
        pNextData = pData->Next;
        ExFreePool(pData);
        pData = pNextData;
    }

    for (fdo = FdoList; fdo !=NULL ; fdo = nextFdo) {

        fdoExtension = fdo->DeviceExtension;
        MarkDeviceDeleted(fdoExtension);

        if (fdoExtension->PcmciaInterruptObject) {
            IoDisconnectInterrupt(fdoExtension->PcmciaInterruptObject);
        }
        //
        // Cleanup socket structures
        //
        for (socket=fdoExtension->SocketList; socket !=NULL; socket=nextSocket) {
            nextSocket = socket->NextSocket;
            ExFreePool(socket);
        }

        //
        // Remove symbolic links
        //
        if (fdoExtension->LinkName.Buffer != NULL) {
            IoDeleteSymbolicLink(&fdoExtension->LinkName);
            RtlFreeUnicodeString(&fdoExtension->LinkName);
        }
        //
        // Clean up all the PDOs
        //
        for (pdo=fdoExtension->PdoList; pdo != NULL; pdo=nextPdo) {
            nextPdo = ((PPDO_EXTENSION) pdo->DeviceExtension)->NextPdoInFdoChain;
            MarkDeviceDeleted((PPDO_EXTENSION)pdo->DeviceExtension);
            PcmciaCleanupPdo(pdo);
            IoDeleteDevice(pdo);
        }

        if (fdoExtension->Flags & PCMCIA_USE_POLLED_CSC) {
                //
                // Cancel the poll timer
                //
                KeCancelTimer(&fdoExtension->PollTimer);
        }

        IoDetachDevice(fdoExtension->LowerDevice);
        nextFdo = fdoExtension->NextFdo;
        IoDeleteDevice(fdo);
    }
}