} // default

    } // switch

    //
    // Device Extenion is gone if the current IRP is IRP_MN_REMOVE_DEVICE
    //
    if ( lockHeld == TRUE ) {
        IoReleaseRemoveLock(&devExt->RemoveLock, Irp);
        DBGPRINT( DBG_COMP_PNP, DBG_LEVEL_INFO, ("DispatchPnP - OUT. Device State=%s\n",
              StateTable[devExt->DevState] ) );
    }

    return status;
}  // End of RamDiskDispatchPnp()

NTSTATUS
RamDiskDispatchPower(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )
/*++ 
Routine Description:

    Dispatch routine for Power management IRPs
    
Arguments:

    DeviceObject    - Supplies the device object.
    
    Irp             - Supplies the I/O request packet. 

Return Value:

    NTSTATUS
    
--*/    
{
    PDEVICE_EXTENSION   devExt;
    NTSTATUS            status = STATUS_SUCCESS;

    PAGED_CODE();

    DBGPRINT( DBG_COMP_POWER, DBG_LEVEL_VERBOSE, ("DispatchPower - IN. Fdo=(%p) Irp=(%p)\n",
                                                        DeviceObject, Irp ) );
    devExt = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;

    //
    // If the device has been removed, the driver should not pass
    // the IRP down to the next lower driver.
    //

    if ( devExt->DevState == REMOVED) {
        PoStartNextPowerIrp( Irp );
        status = STATUS_DELETE_PENDING;
        COMPLETE_REQUEST( Irp, status, 0 );
        return status;
    }

    PoStartNextPowerIrp( Irp );
    IoSkipCurrentIrpStackLocation( Irp );

    DBGPRINT( DBG_COMP_POWER, DBG_LEVEL_VERBOSE, ("DispatchPower - OUT.\n" ) );

    return PoCallDriver( devExt->LowerDeviceObject, Irp );

}  // End of RamDiskDispatchPower()

NTSTATUS
RamDiskDispatchSystemControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )
/*++ 
Routine Description:

    Dispatch routine for WMI IRPs. It just forwards the 
    IRPs to the lower driver.
    
Arguments:

    DeviceObject    - Supplies the device object.
    
    Irp             - Supplies the I/O request packet. 

Return Value:

    NTSTATUS
    
--*/    
{
    PDEVICE_EXTENSION   devExt;

    PAGED_CODE();

    DBGPRINT( DBG_COMP_WMI, DBG_LEVEL_VERBOSE, ("DispatchSystemControl - IN. Fdo=(%p) Irp=(%p)\n",
        DeviceObject, Irp ) );

    devExt = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
    IoSkipCurrentIrpStackLocation( Irp );
    DBGPRINT( DBG_COMP_WMI, DBG_LEVEL_VERBOSE, ("DispatchSystemControl - OUT.\n" ) );
    return IoCallDriver( devExt->LowerDeviceObject, Irp );

}  // End of RamDiskDispatchSystemControl()


NTSTATUS
RamDiskIoCompletionRoutine(
    IN PDEVICE_OBJECT  DeviceObject,
    IN PIRP            Irp,
    IN PKEVENT         Event
    )
/*++ 
Routine Description:

    Io completion routine
    
Arguments:

    DeviceObject    - Supplies the device object.
    
    Irp             - Supplies the I/O request packet. 

    Event           - Supplies the Event to be set.

Return Value:

    NTSTATUS
    
--*/    
{

    KeSetEvent( Event, 0, FALSE );
    return STATUS_MORE_PROCESSING_REQUIRED;

}  // End of RamDiskIoCompletionRoutine()


VOID
RamDiskCleanUp( 
    IN PDEVICE_OBJECT DeviceObject
    )
/*++

Routine Description:

    This routine does the required cleaning like deleting the symbolic link
    releasjing the memory etc.

Arguments:

    DeviceObject - Supplies a pointer to the device object that represents
        the device whose capacity is to be read.

Return Value:

    None.

--*/
{
      
    PDEVICE_EXTENSION   devExt = DeviceObject->DeviceExtension;

    PAGED_CODE();
    DBGPRINT( DBG_COMP_PNP, DBG_LEVEL_VERBOSE, ("RamDiskCleanUp\n" ) );
    
    if ( devExt->Flags & FLAG_LINK_CREATED ) {
        IoDeleteSymbolicLink( &devExt->SymbolicLink );
    }
    if ( devExt->SymbolicLink.Buffer ) {
        ExFreePool( devExt->SymbolicLink.Buffer );
    }
    if ( devExt->DiskRegInfo.DriveLetter.Buffer ) {
        ExFreePool( devExt->DiskRegInfo.DriveLetter.Buffer );
    }
    if ( devExt->DiskImage ) {
        ExFreePool( devExt->DiskImage );
    }
    if ( devExt->LowerDeviceObject ) {
        IoDetachDevice( devExt->LowerDeviceObject );
    }
    IoDeleteDevice( DeviceObject );

    return;
}

VOID
RamDiskRemoveDevice(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine releases the remove lock and calls RamDiskCleanUp
    to do the cleaning

Arguments:

    DeviceObject - Supplies a pointer to the device object that represents
        the device whose capacity is to be read.

Return Value:

    None.

--*/
{
    PDEVICE_EXTENSION           devExt = DeviceObject->DeviceExtension;
    PRAMDISK_DRIVER_EXTENSION   driverExtension;
    NTSTATUS                    status;

    PAGED_CODE();
    DBGPRINT( DBG_COMP_PNP, DBG_LEVEL_VERBOSE, ("RemoveDevice\n" ) );

    #ifdef DBG
    status =
    #endif
    IoSetDeviceInterfaceState (  &devExt->SymbolicLink , FALSE ) ;
    #ifdef DBG
    if ( status != STATUS_SUCCESS )
    {
        DBGPRINT( DBG_COMP_PNP, DBG_LEVEL_VERBOSE, ("IoSetDeviceInterfaceState : reports %d\n" , status ) );
    }
    #endif

    Irp->IoStatus.Status = STATUS_SUCCESS;
    IoSkipCurrentIrpStackLocation( Irp );
    status = IoCallDriver( devExt->LowerDeviceObject, Irp );


    //
    // Set the device status to REMOVED and wait for other drivers 
    // to release the lock, then delete the device object
    //
    devExt->DevState = REMOVED;
    IoReleaseRemoveLockAndWait(&devExt->RemoveLock, Irp);

    driverExtension = IoGetDriverObjectExtension(DeviceObject->DriverObject,
                                             RAMDISK_DRIVER_EXTENSION_KEY);
    ASSERT ( driverExtension != NULL );
	driverExtension->DeviceInitialized = FALSE;

    RamDiskCleanUp( DeviceObject );

    DBGPRINT( DBG_COMP_PNP, DBG_LEVEL_NOTIFY, ("Device Removed succesfully\n" ) );

    return;
} // end RamDiskRemoveDevice()


PSTR
GetPnpIrpName(
    IN UCHAR    PnpMinorFunction
    )
/*++ 
Routine Description:

    This function returns the minor function string for
    the given id.
    
Arguments:

    PnpMinorFunction    - Supplies the Minor function Irp id.
    
Return Value:

    PSTR    - Function name string
    
--*/    
{
    static char    functionName[80];

    PAGED_CODE();

    switch ( PnpMinorFunction ) {

        case IRP_MN_START_DEVICE:                 // 0x00
            return "IRP_MN_START_DEVICE";
            break;

        case IRP_MN_QUERY_REMOVE_DEVICE:          // 0x01
            return "IRP_MN_QUERY_REMOVE_DEVICE";
            break;

        case IRP_MN_REMOVE_DEVICE:                // 0x02
            return "IRP_MN_REMOVE_DEVICE";
            break;

        case IRP_MN_CANCEL_REMOVE_DEVICE:         // 0x03
            return "IRP_MN_CANCEL_REMOVE_DEVICE";
            break;

        case IRP_MN_STOP_DEVICE:                  // 0x04
            return "IRP_MN_STOP_DEVICE";
            break;

        case IRP_MN_QUERY_STOP_DEVICE:            // 0x05
            return "IRP_MN_QUERY_STOP_DEVICE";
            break;

        case IRP_MN_CANCEL_STOP_DEVICE:           // 0x06
            return "IRP_MN_CANCEL_STOP_DEVICE";
            break;

        case IRP_MN_QUERY_DEVICE_RELATIONS:       // 0x07
            return "IRP_MN_QUERY_DEVICE_RELATIONS";
            break;

        case IRP_MN_QUERY_INTERFACE:              // 0x08
            return "IRP_MN_QUERY_INTERFACE";
            break;

        case IRP_MN_QUERY_CAPABILITIES:           // 0x09
            return "IRP_MN_QUERY_CAPABILITIES";
            break;

        case IRP_MN_QUERY_RESOURCES:              // 0x0A
            return "IRP_MN_QUERY_RESOURCES";
            break;

        case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:  // 0x0B
            return "IRP_MN_QUERY_RESOURCE_REQUIREMENTS";
            break;

        case IRP_MN_QUERY_DEVICE_TEXT:            // 0x0C
            return "IRP_MN_QUERY_DEVICE_TEXT";
            break;

        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS: // 0x0D
            return "IRP_MN_FILTER_RESOURCE_REQUIREMENTS";
            break;

        case IRP_MN_READ_CONFIG:                  // 0x0F
            return "IRP_MN_READ_CONFIG";
            break;

        case IRP_MN_WRITE_CONFIG:                 // 0x10
            return "IRP_MN_WRITE_CONFIG";
            break;

        case IRP_MN_EJECT:                        // 0x11
            return "IRP_MN_EJECT";
            break;

        case IRP_MN_SET_LOCK:                     // 0x12
            return "IRP_MN_SET_LOCK";
            break;

        case IRP_MN_QUERY_ID:                     // 0x13
            return "IRP_MN_QUERY_ID";
            break;

        case IRP_MN_QUERY_PNP_DEVICE_STATE:       // 0x14
            return "IRP_MN_QUERY_PNP_DEVICE_STATE";
            break;

        case IRP_MN_QUERY_BUS_INFORMATION:        // 0x15
            return "IRP_MN_QUERY_BUS_INFORMATION";
            break;

        case IRP_MN_DEVICE_USAGE_NOTIFICATION:    // 0x16
            return "IRP_MN_DEVICE_USAGE_NOTIFICATION";
            break;

        case IRP_MN_SURPRISE_REMOVAL:             // 0x17
            return "IRP_MN_SURPRISE_REMOVAL";
            break;

        case IRP_MN_QUERY_LEGACY_BUS_INFORMATION: // 0x18
            return "IRP_MN_QUERY_LEGACY_BUS_INFORMATION";
            break;

        default:
            sprintf( functionName, "Unknown IRP(0x%x)", PnpMinorFunction );
            return functionName;
            break;

    }    // switch
}  // End of GetPnpIrpName()