floppy.c File Reference

#include "precomp.h"
#include <ntddk.h>
#include <debug.h>
#include "ioctl.h"
#include "readwrite.h"

Include dependency graph for floppy.c:

Go to the source code of this file.

Functions
NTSYSAPI NTSTATUS NTAPI	ZwWaitForSingleObject (_In_ HANDLE Handle, _In_ BOOLEAN Alertable, _In_opt_ PLARGE_INTEGER Timeout)
static VOID	Cleanup (PDRIVER_OBJECT DriverObject)
static VOID NTAPI	MotorStopDpcFunc (PKDPC UnusedDpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
VOID NTAPI	StartMotor (PDRIVE_INFO DriveInfo)
VOID NTAPI	StopMotor (PCONTROLLER_INFO ControllerInfo)
NTSTATUS NTAPI	WaitForControllerInterrupt (PCONTROLLER_INFO ControllerInfo, PLARGE_INTEGER Timeout)
static NTSTATUS NTAPI	CreateClose (PDEVICE_OBJECT DeviceObject, PIRP Irp)
static NTSTATUS NTAPI	Recalibrate (PDRIVE_INFO DriveInfo)
NTSTATUS NTAPI	ResetChangeFlag (PDRIVE_INFO DriveInfo)
static VOID NTAPI	Unload (PDRIVER_OBJECT DriverObject)
static NTSTATUS NTAPI	ConfigCallback (PVOID Context, PUNICODE_STRING PathName, INTERFACE_TYPE BusType, ULONG BusNumber, PKEY_VALUE_FULL_INFORMATION *BusInformation, CONFIGURATION_TYPE ControllerType, ULONG ControllerNumber, PKEY_VALUE_FULL_INFORMATION *ControllerInformation, CONFIGURATION_TYPE PeripheralType, ULONG PeripheralNumber, PKEY_VALUE_FULL_INFORMATION *PeripheralInformation)
static BOOLEAN NTAPI	Isr (PKINTERRUPT Interrupt, PVOID ServiceContext)
VOID NTAPI	DpcForIsr (PKDPC UnusedDpc, PVOID Context, PVOID SystemArgument1, PVOID SystemArgument2)
static NTSTATUS NTAPI	InitController (PCONTROLLER_INFO ControllerInfo)
static VOID NTAPI	ReportToMountMgr (UCHAR ControlerId, UCHAR DriveId)
static BOOLEAN NTAPI	AddControllers (PDRIVER_OBJECT DriverObject)
VOID NTAPI	SignalMediaChanged (PDEVICE_OBJECT DeviceObject, PIRP Irp)
static VOID NTAPI	QueueThread (PVOID Context)
NTSTATUS NTAPI	DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)

Variables
static CONTROLLER_INFO	gControllerInfo [MAX_CONTROLLERS]
static ULONG	gNumberOfControllers = 0
static KEVENT	QueueThreadTerminate
static PVOID	QueueThreadObject
static DRIVER_DISPATCH	CreateClose

Function Documentation

AddControllers()

static BOOLEAN NTAPI AddControllers ( PDRIVER_OBJECT  DriverObject )

static

Definition at line 932 of file floppy.c.

{
    INTERFACE_TYPE InterfaceType = Isa;
    CONFIGURATION_TYPE ControllerType = DiskController;
    CONFIGURATION_TYPE PeripheralType = FloppyDiskPeripheral;
    KAFFINITY Affinity;
    DEVICE_DESCRIPTION DeviceDescription;
    UCHAR i;
    UCHAR j;
 
    PAGED_CODE();
 
    /* Find our controllers on all ISA buses */
    IoQueryDeviceDescription(&InterfaceType,
                             NULL,
                             &ControllerType,
                             NULL,
                             &PeripheralType,
                             NULL,
                             ConfigCallback,
                             NULL);
 
    /*
     * w2k breaks the return val from ConfigCallback, so we have to hack around it, rather than just
     * looking for a return value from ConfigCallback.  We expect at least one controller.
     */
    if(!gControllerInfo[0].Populated)
    {
        WARN_(FLOPPY, "AddControllers: failed to get controller info from registry\n");
        return FALSE;
    }
 
    /* Now that we have a controller, set it up with the system */
    for(i = 0; i < gNumberOfControllers && gControllerInfo[i].NumberOfDrives > 0; i++)
    {
        /* 0: Report resource usage to the kernel, to make sure they aren't assigned to anyone else */
        /* FIXME: Implement me. */
 
        /* 1: Set up interrupt */
        gControllerInfo[i].MappedVector = HalGetInterruptVector(gControllerInfo[i].InterfaceType, gControllerInfo[i].BusNumber,
                                          gControllerInfo[i].Level, gControllerInfo[i].Vector,
                                          &gControllerInfo[i].MappedLevel, &Affinity);
 
        /* Must set up the DPC before we connect the interrupt */
        KeInitializeDpc(&gControllerInfo[i].Dpc, DpcForIsr, &gControllerInfo[i]);
 
        INFO_(FLOPPY, "Connecting interrupt %d to controller%d (object 0x%p)\n", gControllerInfo[i].MappedVector,
              i, &gControllerInfo[i]);
 
        /* NOTE: We cannot share our interrupt, even on level-triggered buses.  See Isr() for details. */
        if(IoConnectInterrupt(&gControllerInfo[i].InterruptObject, Isr, &gControllerInfo[i], 0, gControllerInfo[i].MappedVector,
                              gControllerInfo[i].MappedLevel, gControllerInfo[i].MappedLevel, gControllerInfo[i].InterruptMode,
                              FALSE, Affinity, 0) != STATUS_SUCCESS)
        {
            WARN_(FLOPPY, "AddControllers: unable to connect interrupt\n");
            continue;
        }
 
        /* 2: Set up DMA */
        memset(&DeviceDescription, 0, sizeof(DeviceDescription));
        DeviceDescription.Version = DEVICE_DESCRIPTION_VERSION;
        DeviceDescription.DmaChannel = gControllerInfo[i].Dma;
        DeviceDescription.InterfaceType = gControllerInfo[i].InterfaceType;
        DeviceDescription.BusNumber = gControllerInfo[i].BusNumber;
        DeviceDescription.MaximumLength = 2*18*512; /* based on a 1.44MB floppy */
 
        /* DMA 0,1,2,3 are 8-bit; 4,5,6,7 are 16-bit (4 is chain i think) */
        DeviceDescription.DmaWidth = gControllerInfo[i].Dma > 3 ? Width16Bits: Width8Bits;
 
        gControllerInfo[i].AdapterObject = HalGetAdapter(&DeviceDescription, &gControllerInfo[i].MapRegisters);
 
        if(!gControllerInfo[i].AdapterObject)
        {
            WARN_(FLOPPY, "AddControllers: unable to allocate an adapter object\n");
            IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
            gControllerInfo[i].InterruptObject = NULL;
            continue;
        }
 
        /* 2b: Initialize the new controller */
        if(InitController(&gControllerInfo[i]) != STATUS_SUCCESS)
        {
            WARN_(FLOPPY, "AddControllers(): Unable to set up controller %d - initialization failed\n", i);
            IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
            gControllerInfo[i].InterruptObject = NULL;
            continue;
        }
 
        /* 2c: Set the controller's initialized flag so we know to release stuff in Unload */
        gControllerInfo[i].Initialized = TRUE;
 
        /* 3: per-drive setup */
        for(j = 0; j < gControllerInfo[i].NumberOfDrives; j++)
        {
            UNICODE_STRING DeviceName;
            UNICODE_STRING ArcPath;
            UCHAR DriveNumber;
 
            INFO_(FLOPPY, "AddControllers(): Configuring drive %d on controller %d\n", i, j);
 
            /*
             * 3a: create a device object for the drive
             * Controllers and drives are 0-based, so the combos are:
             * 0: 0,0
             * 1: 0,1
             * 2: 0,2
             * 3: 0,3
             * 4: 1,0
             * 5: 1,1
             * ...
             * 14: 3,2
             * 15: 3,3
             */
 
            DriveNumber = (UCHAR)(i*4 + j); /* loss of precision is OK; there are only 16 of 'em */
 
            _swprintf(gControllerInfo[i].DriveInfo[j].DeviceNameBuffer, L"\\Device\\Floppy%d", DriveNumber);
            RtlInitUnicodeString(&DeviceName, gControllerInfo[i].DriveInfo[j].DeviceNameBuffer);
 
            if(IoCreateDevice(DriverObject, sizeof(PVOID), &DeviceName,
                              FILE_DEVICE_DISK, FILE_REMOVABLE_MEDIA | FILE_FLOPPY_DISKETTE, FALSE,
                              &gControllerInfo[i].DriveInfo[j].DeviceObject) != STATUS_SUCCESS)
            {
                WARN_(FLOPPY, "AddControllers: unable to register a Device object\n");
                IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
                gControllerInfo[i].InterruptObject = NULL;
                continue; /* continue on to next drive */
            }
 
            INFO_(FLOPPY, "AddControllers: New device: %S (0x%p)\n",
                          gControllerInfo[i].DriveInfo[j].DeviceNameBuffer,
                          gControllerInfo[i].DriveInfo[j].DeviceObject);
 
            /* 3b.5: Create an ARC path in case we're booting from this drive */
            _swprintf(gControllerInfo[i].DriveInfo[j].ArcPathBuffer,
                      L"\\ArcName\\multi(%d)disk(%d)fdisk(%d)", gControllerInfo[i].BusNumber, i, DriveNumber);
 
            RtlInitUnicodeString(&ArcPath, gControllerInfo[i].DriveInfo[j].ArcPathBuffer);
            IoAssignArcName(&ArcPath, &DeviceName);
 
            /* 3c: Set flags up */
            gControllerInfo[i].DriveInfo[j].DeviceObject->Flags |= DO_DIRECT_IO;
 
            /* 3d: Increase global floppy drives count */
            IoGetConfigurationInformation()->FloppyCount++;
 
            /* 3e: Set up the DPC */
            IoInitializeDpcRequest(gControllerInfo[i].DriveInfo[j].DeviceObject, (PIO_DPC_ROUTINE)DpcForIsr);
 
            /* 3f: Point the device extension at our DriveInfo struct */
            gControllerInfo[i].DriveInfo[j].DeviceObject->DeviceExtension = &gControllerInfo[i].DriveInfo[j];
 
            /* 3g: neat comic strip */
 
            /* 3h: set the initial media type to unknown */
            memset(&gControllerInfo[i].DriveInfo[j].DiskGeometry, 0, sizeof(DISK_GEOMETRY));
            gControllerInfo[i].DriveInfo[j].DiskGeometry.MediaType = Unknown;
 
            /* 3i: Now that we're done, set the Initialized flag so we know to free this in Unload */
            gControllerInfo[i].DriveInfo[j].Initialized = TRUE;
 
            /* 3j: Clear the DO_DEVICE_INITIALIZING flag */
            gControllerInfo[i].DriveInfo[j].DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 
            /* 3k: Report to the MountMgr */
            ReportToMountMgr(i, j);
 
            /* 3l: Attempt to get drive info - if a floppy is already present */
            StartMotor(&gControllerInfo[i].DriveInfo[j]);
            RWDetermineMediaType(&gControllerInfo[i].DriveInfo[j], TRUE);
            StopMotor(gControllerInfo[i].DriveInfo[j].ControllerInfo);
        }
    }
 
    INFO_(FLOPPY, "AddControllers: --------------------------------------------> finished adding controllers\n");
 
    return (IoGetConfigurationInformation()->FloppyCount != 0);
}

Referenced by DriverEntry().

Cleanup()

static VOID Cleanup ( PDRIVER_OBJECT  DriverObject )

static

Definition at line 72 of file floppy.c.

{
    ULONG i, j;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER(DriverObject);
 
    if (QueueThreadObject)
    {
        KeSetEvent(&QueueThreadTerminate, 0, FALSE);
        KeWaitForSingleObject(QueueThreadObject, Executive, KernelMode, FALSE, NULL);
        ObDereferenceObject(QueueThreadObject);
        QueueThreadObject = NULL;
    }
 
    for (i = 0; i < gNumberOfControllers; i++)
    {
        for (j = 0; j < gControllerInfo[i].NumberOfDrives; j++)
        {
            if (!gControllerInfo[i].DriveInfo[j].Initialized)
                continue;
 
            if (gControllerInfo[i].DriveInfo[j].DeviceObject)
            {
                UNICODE_STRING Link;
 
                RtlInitUnicodeString(&Link, gControllerInfo[i].DriveInfo[j].ArcPathBuffer);
                IoDeassignArcName(&Link);
 
                IoDeleteDevice(gControllerInfo[i].DriveInfo[j].DeviceObject);
                gControllerInfo[i].DriveInfo[j].DeviceObject = NULL;
            }
 
            gControllerInfo[i].DriveInfo[j].Initialized = FALSE;
        }
 
        if (gControllerInfo[i].InterruptObject)
        {
            IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
            gControllerInfo[i].InterruptObject = NULL;
        }
 
        if (gControllerInfo[i].Initialized)
        {
            if (HwPowerOff(&gControllerInfo[i]) != STATUS_SUCCESS)
            {
                WARN_(FLOPPY, "cleanup: warning: HwPowerOff failed\n");
            }
 
            gControllerInfo[i].Initialized = FALSE;
        }
    }
}

ConfigCallback()

static NTSTATUS NTAPI ConfigCallback ( PVOID  Context, PUNICODE_STRING  PathName, INTERFACE_TYPE  BusType, ULONG  BusNumber, PKEY_VALUE_FULL_INFORMATION *  BusInformation, CONFIGURATION_TYPE  ControllerType, ULONG  ControllerNumber, PKEY_VALUE_FULL_INFORMATION *  ControllerInformation, CONFIGURATION_TYPE  PeripheralType, ULONG  PeripheralNumber, PKEY_VALUE_FULL_INFORMATION *  PeripheralInformation  )

static

Definition at line 456 of file floppy.c.

{
    PKEY_VALUE_FULL_INFORMATION ControllerFullDescriptor = ControllerInformation[IoQueryDeviceConfigurationData];
    PCM_FULL_RESOURCE_DESCRIPTOR ControllerResourceDescriptor = (PCM_FULL_RESOURCE_DESCRIPTOR)((PCHAR)ControllerFullDescriptor +
            ControllerFullDescriptor->DataOffset);
 
    PKEY_VALUE_FULL_INFORMATION PeripheralFullDescriptor = PeripheralInformation[IoQueryDeviceConfigurationData];
    PCM_FULL_RESOURCE_DESCRIPTOR PeripheralResourceDescriptor = (PCM_FULL_RESOURCE_DESCRIPTOR)((PCHAR)PeripheralFullDescriptor +
            PeripheralFullDescriptor->DataOffset);
 
    PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
    PCM_FLOPPY_DEVICE_DATA FloppyDeviceData;
    UCHAR i;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER(PeripheralType);
    UNREFERENCED_PARAMETER(PeripheralNumber);
    UNREFERENCED_PARAMETER(BusInformation);
    UNREFERENCED_PARAMETER(Context);
    UNREFERENCED_PARAMETER(ControllerType);
    UNREFERENCED_PARAMETER(PathName);
 
 
    TRACE_(FLOPPY, "ConfigCallback called with ControllerNumber %d\n", ControllerNumber);
 
    gControllerInfo[gNumberOfControllers].ControllerNumber = ControllerNumber;
    gControllerInfo[gNumberOfControllers].InterfaceType = BusType;
    gControllerInfo[gNumberOfControllers].BusNumber = BusNumber;
 
    /* Get controller interrupt level/vector, dma channel, and port base */
    for(i = 0; i < ControllerResourceDescriptor->PartialResourceList.Count; i++)
    {
        KeInitializeEvent(&gControllerInfo[gNumberOfControllers].SynchEvent, NotificationEvent, FALSE);
 
        PartialDescriptor = &ControllerResourceDescriptor->PartialResourceList.PartialDescriptors[i];
 
        if(PartialDescriptor->Type == CmResourceTypeInterrupt)
        {
            gControllerInfo[gNumberOfControllers].Level = PartialDescriptor->u.Interrupt.Level;
            gControllerInfo[gNumberOfControllers].Vector = PartialDescriptor->u.Interrupt.Vector;
 
            if(PartialDescriptor->Flags & CM_RESOURCE_INTERRUPT_LATCHED)
                gControllerInfo[gNumberOfControllers].InterruptMode = Latched;
            else
                gControllerInfo[gNumberOfControllers].InterruptMode = LevelSensitive;
        }
 
        else if(PartialDescriptor->Type == CmResourceTypePort)
        {
            PHYSICAL_ADDRESS TranslatedAddress;
            ULONG AddressSpace = 0x1; /* I/O Port Range */
 
            if(!HalTranslateBusAddress(BusType, BusNumber, PartialDescriptor->u.Port.Start, &AddressSpace, &TranslatedAddress))
            {
                WARN_(FLOPPY, "HalTranslateBusAddress failed; returning\n");
                return STATUS_IO_DEVICE_ERROR;
            }
 
            if(AddressSpace == 0)
                gControllerInfo[gNumberOfControllers].BaseAddress = MmMapIoSpace(TranslatedAddress, FDC_PORT_BYTES, MmNonCached);
            else
                gControllerInfo[gNumberOfControllers].BaseAddress = (PUCHAR)(ULONG_PTR)TranslatedAddress.QuadPart;
        }
 
        else if(PartialDescriptor->Type == CmResourceTypeDma)
            gControllerInfo[gNumberOfControllers].Dma = PartialDescriptor->u.Dma.Channel;
    }
 
    /* Start with 0 drives, then go looking */
    gControllerInfo[gNumberOfControllers].NumberOfDrives = 0;
 
    /* learn about drives attached to controller */
    for(i = 0; i < PeripheralResourceDescriptor->PartialResourceList.Count; i++)
    {
        PDRIVE_INFO DriveInfo = &gControllerInfo[gNumberOfControllers].DriveInfo[i];
 
        PartialDescriptor = &PeripheralResourceDescriptor->PartialResourceList.PartialDescriptors[i];
 
        if(PartialDescriptor->Type != CmResourceTypeDeviceSpecific)
            continue;
 
        FloppyDeviceData = (PCM_FLOPPY_DEVICE_DATA)(PartialDescriptor + 1);
 
        DriveInfo->ControllerInfo = &gControllerInfo[gNumberOfControllers];
        DriveInfo->UnitNumber = i;
 
        DriveInfo->FloppyDeviceData.MaxDensity = FloppyDeviceData->MaxDensity;
        DriveInfo->FloppyDeviceData.MountDensity = FloppyDeviceData->MountDensity;
        DriveInfo->FloppyDeviceData.StepRateHeadUnloadTime = FloppyDeviceData->StepRateHeadUnloadTime;
        DriveInfo->FloppyDeviceData.HeadLoadTime = FloppyDeviceData->HeadLoadTime;
        DriveInfo->FloppyDeviceData.MotorOffTime = FloppyDeviceData->MotorOffTime;
        DriveInfo->FloppyDeviceData.SectorLengthCode = FloppyDeviceData->SectorLengthCode;
        DriveInfo->FloppyDeviceData.SectorPerTrack = FloppyDeviceData->SectorPerTrack;
        DriveInfo->FloppyDeviceData.ReadWriteGapLength = FloppyDeviceData->ReadWriteGapLength;
        DriveInfo->FloppyDeviceData.FormatGapLength = FloppyDeviceData->FormatGapLength;
        DriveInfo->FloppyDeviceData.FormatFillCharacter = FloppyDeviceData->FormatFillCharacter;
        DriveInfo->FloppyDeviceData.HeadSettleTime = FloppyDeviceData->HeadSettleTime;
        DriveInfo->FloppyDeviceData.MotorSettleTime = FloppyDeviceData->MotorSettleTime;
        DriveInfo->FloppyDeviceData.MaximumTrackValue = FloppyDeviceData->MaximumTrackValue;
        DriveInfo->FloppyDeviceData.DataTransferLength = FloppyDeviceData->DataTransferLength;
 
        /* Once it's all set up, acknowledge its existence in the controller info object */
        gControllerInfo[gNumberOfControllers].NumberOfDrives++;
    }
 
    gControllerInfo[gNumberOfControllers].Populated = TRUE;
    gNumberOfControllers++;
 
    return STATUS_SUCCESS;
}

Referenced by AddControllers().

CreateClose()

static NTSTATUS NTAPI CreateClose ( PDEVICE_OBJECT  DeviceObject, PIRP  Irp  )

static

Definition at line 252 of file floppy.c.

{
    UNREFERENCED_PARAMETER(DeviceObject);
 
    TRACE_(FLOPPY, "CreateClose called\n");
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = FILE_OPENED;
 
    IoCompleteRequest(Irp, IO_DISK_INCREMENT);
 
    return STATUS_SUCCESS;
}

DpcForIsr()

VOID NTAPI DpcForIsr	(	PKDPC	UnusedDpc,
		PVOID	Context,
		PVOID	SystemArgument1,
		PVOID	SystemArgument2
	)

Definition at line 658 of file floppy.c.

{
    PCONTROLLER_INFO ControllerInfo = (PCONTROLLER_INFO)Context;
 
    UNREFERENCED_PARAMETER(UnusedDpc);
    UNREFERENCED_PARAMETER(SystemArgument1);
    UNREFERENCED_PARAMETER(SystemArgument2);
 
    ASSERT(ControllerInfo);
 
    TRACE_(FLOPPY, "DpcForIsr called\n");
 
    KeSetEvent(&ControllerInfo->SynchEvent, EVENT_INCREMENT, FALSE);
}

Referenced by AddControllers().

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	PDRIVER_OBJECT	DriverObject,
		PUNICODE_STRING	RegistryPath
	)

Definition at line 1240 of file floppy.c.

{
    HANDLE ThreadHandle;
 
    UNREFERENCED_PARAMETER(RegistryPath);
 
    if (IsNEC_98)
    {
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /*
     * Set up dispatch routines
     */
    DriverObject->MajorFunction[IRP_MJ_CREATE]         = (PDRIVER_DISPATCH)CreateClose;
    DriverObject->MajorFunction[IRP_MJ_CLOSE]          = (PDRIVER_DISPATCH)CreateClose;
    DriverObject->MajorFunction[IRP_MJ_READ]           = (PDRIVER_DISPATCH)ReadWrite;
    DriverObject->MajorFunction[IRP_MJ_WRITE]          = (PDRIVER_DISPATCH)ReadWrite;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = (PDRIVER_DISPATCH)DeviceIoctl;
 
    DriverObject->DriverUnload = Unload;
 
    /*
     * We depend on some zeroes in these structures.  I know this is supposed to be
     * initialized to 0 by the complier but this makes me feel beter.
     */
    memset(&gControllerInfo, 0, sizeof(gControllerInfo));
 
    /*
     * Set up queue.  This routine cannot fail (trust me, I wrote it).
     */
    IoCsqInitialize(&Csq, CsqInsertIrp, CsqRemoveIrp, CsqPeekNextIrp,
                    CsqAcquireLock, CsqReleaseLock, CsqCompleteCanceledIrp);
 
    /*
     * ...and its lock
     */
    KeInitializeSpinLock(&IrpQueueLock);
 
    /*
     * ...and the queue list itself
     */
    InitializeListHead(&IrpQueue);
 
    /*
     * The queue is counted by a semaphore.  The queue management thread
     * blocks on this semaphore, so if requests come in faster than the queue
     * thread can handle them, the semaphore count goes up.
     */
    KeInitializeSemaphore(&QueueSemaphore, 0, 0x7fffffff);
 
    /*
     * Event to terminate that thread
     */
    KeInitializeEvent(&QueueThreadTerminate, NotificationEvent, FALSE);
 
    /*
     * Create the queue processing thread.  Save its handle in the global variable
     * ThreadHandle so we can wait on its termination during Unload.
     */
    if(PsCreateSystemThread(&ThreadHandle, THREAD_ALL_ACCESS, 0, 0, 0, QueueThread, 0) != STATUS_SUCCESS)
    {
        WARN_(FLOPPY, "Unable to create system thread; failing init\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    if(ObReferenceObjectByHandle(ThreadHandle, STANDARD_RIGHTS_ALL, *PsThreadType, KernelMode, &QueueThreadObject, NULL) != STATUS_SUCCESS)
    {
        WARN_(FLOPPY, "Unable to reference returned thread handle; failing init\n");
        KeSetEvent(&QueueThreadTerminate, 0, FALSE);
        ZwWaitForSingleObject(ThreadHandle, FALSE, NULL);
        ZwClose(ThreadHandle);
        return STATUS_UNSUCCESSFUL;
    }
 
    /*
     * Close the handle, now that we have the object pointer and a reference of our own.
     * The handle will certainly not be valid in the context of the caller next time we
     * need it, as handles are process-specific.
     */
    ZwClose(ThreadHandle);
 
    /*
     * Start the device discovery process.  Returns STATUS_SUCCESS if
     * it finds even one drive attached to one controller.
     */
    if(!AddControllers(DriverObject))
    {
        Cleanup(DriverObject);
        return STATUS_NO_SUCH_DEVICE;
    }
 
    return STATUS_SUCCESS;
}

InitController()

static NTSTATUS NTAPI InitController ( PCONTROLLER_INFO  ControllerInfo )

static

Definition at line 691 of file floppy.c.

{
    int i;
    UCHAR HeadLoadTime;
    UCHAR HeadUnloadTime;
    UCHAR StepRateTime;
    UCHAR ControllerVersion;
 
    PAGED_CODE();
    ASSERT(ControllerInfo);
 
    TRACE_(FLOPPY, "InitController called with Controller 0x%p\n", ControllerInfo);
 
    /* Get controller in a known state */
    if(HwConfigure(ControllerInfo, FALSE, TRUE, TRUE, 0, 0) != STATUS_SUCCESS)
    {
        WARN_(FLOPPY, "InitController: unable to configure controller\n");
        return STATUS_IO_DEVICE_ERROR;
    }
 
    /* Get the controller version */
    ControllerVersion = HwGetVersion(ControllerInfo);
 
    KeClearEvent(&ControllerInfo->SynchEvent);
 
    /* Reset the controller */
    if(HwReset(ControllerInfo) != STATUS_SUCCESS)
    {
        WARN_(FLOPPY, "InitController: unable to reset controller\n");
        return STATUS_IO_DEVICE_ERROR;
    }
 
    INFO_(FLOPPY, "InitController: waiting for initial interrupt\n");
 
    /* Wait for an interrupt */
    WaitForControllerInterrupt(ControllerInfo, NULL);
 
    /* Reset means you have to clear each of the four interrupts (one per drive) */
    for(i = 0; i < MAX_DRIVES_PER_CONTROLLER; i++)
    {
        INFO_(FLOPPY, "InitController: Sensing interrupt %d\n", i);
 
        if(HwSenseInterruptStatus(ControllerInfo) != STATUS_SUCCESS)
        {
            WARN_(FLOPPY, "InitController: Unable to clear interrupt 0x%x\n", i);
            return STATUS_IO_DEVICE_ERROR;
        }
    }
 
    INFO_(FLOPPY, "InitController: done sensing interrupts\n");
 
    /* Next, see if we have the right version to do implied seek */
    if(ControllerVersion == VERSION_ENHANCED)
    {
        /* If so, set that up -- all defaults below except first TRUE for EIS */
        if(HwConfigure(ControllerInfo, TRUE, TRUE, TRUE, 0, 0) != STATUS_SUCCESS)
        {
            WARN_(FLOPPY, "InitController: unable to set up implied seek\n");
            ControllerInfo->ImpliedSeeks = FALSE;
        }
        else
        {
            INFO_(FLOPPY, "InitController: implied seeks set!\n");
            ControllerInfo->ImpliedSeeks = TRUE;
        }
 
        /*
         * FIXME: Figure out the answer to the below
         *
         * I must admit that I'm really confused about the Model 30 issue.  At least one
         * important bit (the disk change bit in the DIR) is flipped if this is a Model 30
         * controller.  However, at least one other floppy driver believes that there are only
         * two computers that are guaranteed to have a Model 30 controller:
         *  - IBM Thinkpad 750
         *  - IBM PS2e
         *
         * ...and another driver only lists a config option for "thinkpad", that flips
         * the change line.  A third driver doesn't mention the Model 30 issue at all.
         *
         * What I can't tell is whether or not the average, run-of-the-mill computer now has
         * a Model 30 controller.  For the time being, I'm going to wire this to FALSE,
         * and just not support the computers mentioned above, while I try to figure out
         * how ubiquitous these newfangled 30 thingies are.
         */
        //ControllerInfo->Model30 = TRUE;
        ControllerInfo->Model30 = FALSE;
    }
    else
    {
        INFO_(FLOPPY, "InitController: enhanced version not supported; disabling implied seeks\n");
        ControllerInfo->ImpliedSeeks = FALSE;
        ControllerInfo->Model30 = FALSE;
    }
 
    /* Specify */
    WARN_(FLOPPY, "FIXME: Figure out speed\n");
    HeadLoadTime = SPECIFY_HLT_500K;
    HeadUnloadTime = SPECIFY_HUT_500K;
    StepRateTime = SPECIFY_SRT_500K;
 
    INFO_(FLOPPY, "InitController: setting data rate\n");
 
    /* Set data rate */
    if(HwSetDataRate(ControllerInfo, DRSR_DSEL_500KBPS) != STATUS_SUCCESS)
    {
        WARN_(FLOPPY, "InitController: unable to set data rate\n");
        return STATUS_IO_DEVICE_ERROR;
    }
 
    INFO_(FLOPPY, "InitController: issuing specify command to controller\n");
 
    /* Don't disable DMA --> enable dma (dumb & confusing) */
    if(HwSpecify(ControllerInfo, HeadLoadTime, HeadUnloadTime, StepRateTime, FALSE) != STATUS_SUCCESS)
    {
        WARN_(FLOPPY, "InitController: unable to specify options\n");
        return STATUS_IO_DEVICE_ERROR;
    }
 
    /* Init the stop stuff */
    KeInitializeDpc(&ControllerInfo->MotorStopDpc, MotorStopDpcFunc, ControllerInfo);
    KeInitializeTimer(&ControllerInfo->MotorTimer);
    KeInitializeEvent(&ControllerInfo->MotorStoppedEvent, NotificationEvent, FALSE);
    ControllerInfo->StopDpcQueued = FALSE;
 
    /*
     * Recalibrate each drive on the controller (depends on StartMotor, which depends on the timer stuff above)
     * We don't even know if there is a disk in the drive, so this may not work, but that's OK.
     */
    for(i = 0; i < ControllerInfo->NumberOfDrives; i++)
    {
        INFO_(FLOPPY, "InitController: recalibrating drive 0x%x on controller 0x%p\n", i, ControllerInfo);
        Recalibrate(&ControllerInfo->DriveInfo[i]);
    }
 
    INFO_(FLOPPY, "InitController: done initializing; returning STATUS_SUCCESS\n");
 
    return STATUS_SUCCESS;
}

Referenced by AddControllers().

Isr()

static BOOLEAN NTAPI Isr ( PKINTERRUPT  Interrupt, PVOID  ServiceContext  )

static

Definition at line 609 of file floppy.c.

{
    PCONTROLLER_INFO ControllerInfo = (PCONTROLLER_INFO)ServiceContext;
 
    UNREFERENCED_PARAMETER(Interrupt);
 
    ASSERT(ControllerInfo);
 
    TRACE_(FLOPPY, "ISR called\n");
 
    /*
     * Due to the stupidity of the drive/controller relationship on the floppy drive, only one device object
     * can have an active interrupt pending.  Due to the nature of these IRPs, though, there will only ever
     * be one thread expecting an interrupt at a time, and furthermore, Interrupts (outside of spurious ones)
     * won't ever happen unless a thread is expecting them.  Therefore, all we have to do is signal an event
     * and we're done.  Queue a DPC and leave.
     */
    KeInsertQueueDpc(&ControllerInfo->Dpc, NULL, NULL);
 
    return TRUE;
}

Referenced by _HalpDismissIrqGeneric(), _HalpDismissIrqLevel(), AddControllers(), HalpDismissIrq07(), HalpDismissIrq07Level(), HalpDismissIrq15(), HalpDismissIrq15Level(), and HDA_SetupDmaEngineWithBdl().

MotorStopDpcFunc()

static VOID NTAPI MotorStopDpcFunc ( PKDPC  UnusedDpc, PVOID  DeferredContext, PVOID  SystemArgument1, PVOID  SystemArgument2  )

static

Definition at line 128 of file floppy.c.

{
    PCONTROLLER_INFO ControllerInfo = (PCONTROLLER_INFO)DeferredContext;
 
    UNREFERENCED_PARAMETER(SystemArgument1);
    UNREFERENCED_PARAMETER(SystemArgument2);
    UNREFERENCED_PARAMETER(UnusedDpc);
 
    ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
    ASSERT(ControllerInfo);
 
    TRACE_(FLOPPY, "MotorStopDpcFunc called\n");
 
    HwTurnOffMotor(ControllerInfo);
    ControllerInfo->StopDpcQueued = FALSE;
    KeSetEvent(&ControllerInfo->MotorStoppedEvent, EVENT_INCREMENT, FALSE);
}

Referenced by InitController().

QueueThread()

static VOID NTAPI QueueThread ( PVOID  Context )

static

Definition at line 1172 of file floppy.c.

{
    PIRP Irp;
    PIO_STACK_LOCATION Stack;
    PDEVICE_OBJECT DeviceObject;
    PVOID Objects[2];
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER(Context);
 
    Objects[0] = &QueueSemaphore;
    Objects[1] = &QueueThreadTerminate;
 
    for(;;)
    {
        KeWaitForMultipleObjects(2, Objects, WaitAny, Executive, KernelMode, FALSE, NULL, NULL);
 
        if(KeReadStateEvent(&QueueThreadTerminate))
        {
            INFO_(FLOPPY, "QueueThread terminating\n");
            return;
        }
 
        INFO_(FLOPPY, "QueueThread: servicing an IRP\n");
 
        Irp = IoCsqRemoveNextIrp(&Csq, 0);
 
        /* we won't get an irp if it was canceled */
        if(!Irp)
        {
            INFO_(FLOPPY, "QueueThread: IRP queue empty\n");
            continue;
        }
 
        DeviceObject = (PDEVICE_OBJECT)Irp->Tail.Overlay.DriverContext[0];
 
        ASSERT(DeviceObject);
 
        Stack = IoGetCurrentIrpStackLocation(Irp);
 
        /* Decide what to do with the IRP */
        switch(Stack->MajorFunction)
        {
        case IRP_MJ_READ:
        case IRP_MJ_WRITE:
            ReadWritePassive(DeviceObject->DeviceExtension, Irp);
            break;
 
        case IRP_MJ_DEVICE_CONTROL:
            DeviceIoctlPassive(DeviceObject->DeviceExtension, Irp);
            break;
 
        default:
            WARN_(FLOPPY, "QueueThread(): Unrecognized irp: mj: 0x%x\n", Stack->MajorFunction);
            Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
            Irp->IoStatus.Information = 0;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
        }
    }
}

Referenced by DriverEntry().

Recalibrate()

static NTSTATUS NTAPI Recalibrate ( PDRIVE_INFO  DriveInfo )

static

Definition at line 284 of file floppy.c.

{
    NTSTATUS Status;
    ULONG i;
 
    PAGED_CODE();
    ASSERT(DriveInfo);
 
    /* first turn on the motor */
    /* Must stop after every start, prior to return */
    StartMotor(DriveInfo);
 
    /* set the data rate */
    WARN_(FLOPPY, "FIXME: UN-HARDCODE DATA RATE\n");
    if(HwSetDataRate(DriveInfo->ControllerInfo, 0) != STATUS_SUCCESS)
    {
        WARN_(FLOPPY, "Recalibrate: HwSetDataRate failed\n");
        StopMotor(DriveInfo->ControllerInfo);
        return STATUS_IO_DEVICE_ERROR;
    }
 
    /* clear the event just in case the last call forgot */
    KeClearEvent(&DriveInfo->ControllerInfo->SynchEvent);
 
    /* sometimes you have to do this twice; we'll just do it twice all the time since
     * we don't know if the people calling this Recalibrate routine expect a disk to
     * even be in the drive, and if so, if that disk is formatted.
     */
    for(i = 0; i < 2; i++)
    {
        /* Send the command */
        Status = HwRecalibrate(DriveInfo);
        if(Status != STATUS_SUCCESS)
        {
            WARN_(FLOPPY, "Recalibrate: HwRecalibrate returned error\n");
            continue;
        }
 
        WaitForControllerInterrupt(DriveInfo->ControllerInfo, NULL);
 
        /* Get the results */
        Status = HwRecalibrateResult(DriveInfo->ControllerInfo);
        if(Status != STATUS_SUCCESS)
        {
            WARN_(FLOPPY, "Recalibrate: HwRecalibrateResult returned error\n");
            break;
        }
    }
 
    KeClearEvent(&DriveInfo->ControllerInfo->SynchEvent);
 
    /* Must stop after every start, prior to return */
    StopMotor(DriveInfo->ControllerInfo);
 
    return Status;
}

Referenced by InitController(), and ResetChangeFlag().

ReportToMountMgr()

static VOID NTAPI ReportToMountMgr ( UCHAR  ControlerId, UCHAR  DriveId  )

static

Definition at line 840 of file floppy.c.

{
    NTSTATUS              Status;
    UNICODE_STRING        MountMgrDevice;
    PDEVICE_OBJECT        DeviceObject;
    PFILE_OBJECT          FileObject;
    PMOUNTMGR_TARGET_NAME MountTarget;
    ULONG                 DeviceLen;
    PIRP                  Irp;
    KEVENT                Event;
    IO_STATUS_BLOCK       IoStatus;
 
    /* First, get MountMgr DeviceObject */
    RtlInitUnicodeString(&MountMgrDevice, MOUNTMGR_DEVICE_NAME);
    Status = IoGetDeviceObjectPointer(&MountMgrDevice, FILE_READ_ATTRIBUTES,
                                      &FileObject, &DeviceObject);
 
    if(!NT_SUCCESS(Status))
    {
        WARN_(FLOPPY, "ReportToMountMgr: Can't get MountMgr pointers %lx\n", Status);
        return;
    }
 
    DeviceLen = wcslen(&gControllerInfo[ControlerId].DriveInfo[DriveId].DeviceNameBuffer[0]) * sizeof(WCHAR);
 
    /* Allocate input buffer to report our floppy device */
    MountTarget = ExAllocatePool(NonPagedPool,
                                 sizeof(MOUNTMGR_TARGET_NAME) + DeviceLen);
 
    if(!MountTarget)
    {
        WARN_(FLOPPY, "ReportToMountMgr: Allocation of mountTarget failed\n");
        ObDereferenceObject(FileObject);
        return;
    }
 
    MountTarget->DeviceNameLength = DeviceLen;
    RtlCopyMemory(MountTarget->DeviceName,
                  gControllerInfo[ControlerId].DriveInfo[DriveId].DeviceNameBuffer,
                  DeviceLen);
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    /* Build the IRP used to communicate with the MountMgr */
    Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_VOLUME_ARRIVAL_NOTIFICATION,
                                        DeviceObject,
                                        MountTarget,
                                        sizeof(MOUNTMGR_TARGET_NAME) + DeviceLen,
                                        NULL,
                                        0,
                                        FALSE,
                                        &Event,
                                        &IoStatus);
 
    if(!Irp)
    {
        WARN_(FLOPPY, "ReportToMountMgr: Allocation of irp failed\n");
        ExFreePool(MountTarget);
        ObDereferenceObject(FileObject);
        return;
    }
 
    /* Call the MountMgr */
    Status = IoCallDriver(DeviceObject, Irp);
 
    if (Status == STATUS_PENDING) {
        KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
        Status = IoStatus.Status;
    }
 
    /* We're done */
 
    INFO_(FLOPPY, "Reported to the MountMgr: %lx\n", Status);
 
    ExFreePool(MountTarget);
    ObDereferenceObject(FileObject);
 
    return;
}

Referenced by AddControllers().

ResetChangeFlag()

NTSTATUS NTAPI ResetChangeFlag

(

PDRIVE_INFO

DriveInfo

)

Definition at line 354 of file floppy.c.

{
    BOOLEAN DiskChanged;
 
    PAGED_CODE();
    ASSERT(DriveInfo);
 
    TRACE_(FLOPPY, "ResetChangeFlag called\n");
 
    /* Try to recalibrate.  We don't care if it works. */
    Recalibrate(DriveInfo);
 
    /* clear spurious interrupts in prep for seeks */
    KeClearEvent(&DriveInfo->ControllerInfo->SynchEvent);
 
    /* must re-start the drive because Recalibrate() stops it */
    StartMotor(DriveInfo);
 
    /* Seek to 1 */
    if(HwSeek(DriveInfo, 1) != STATUS_SUCCESS)
    {
        WARN_(FLOPPY, "ResetChangeFlag(): HwSeek failed; returning STATUS_IO_DEVICE_ERROR\n");
        StopMotor(DriveInfo->ControllerInfo);
        return STATUS_IO_DEVICE_ERROR;
    }
 
    WaitForControllerInterrupt(DriveInfo->ControllerInfo, NULL);
 
    if(HwSenseInterruptStatus(DriveInfo->ControllerInfo) != STATUS_SUCCESS)
    {
        WARN_(FLOPPY, "ResetChangeFlag(): HwSenseInterruptStatus failed; bailing out\n");
        StopMotor(DriveInfo->ControllerInfo);
        return STATUS_IO_DEVICE_ERROR;
    }
 
    /* Seek back to 0 */
    if(HwSeek(DriveInfo, 0) != STATUS_SUCCESS)
    {
        WARN_(FLOPPY, "ResetChangeFlag(): HwSeek failed; returning STATUS_IO_DEVICE_ERROR\n");
        StopMotor(DriveInfo->ControllerInfo);
        return STATUS_IO_DEVICE_ERROR;
    }
 
    WaitForControllerInterrupt(DriveInfo->ControllerInfo, NULL);
 
    if(HwSenseInterruptStatus(DriveInfo->ControllerInfo) != STATUS_SUCCESS)
    {
        WARN_(FLOPPY, "ResetChangeFlag(): HwSenseInterruptStatus #2 failed; bailing\n");
        StopMotor(DriveInfo->ControllerInfo);
        return STATUS_IO_DEVICE_ERROR;
    }
 
    /* Check the change bit */
    if(HwDiskChanged(DriveInfo, &DiskChanged) != STATUS_SUCCESS)
    {
        WARN_(FLOPPY, "ResetChangeFlag(): HwDiskChanged failed; returning STATUS_IO_DEVICE_ERROR\n");
        StopMotor(DriveInfo->ControllerInfo);
        return STATUS_IO_DEVICE_ERROR;
    }
 
    StopMotor(DriveInfo->ControllerInfo);
 
    /* if the change flag is still set, there's probably no media in the drive. */
    if(DiskChanged)
        return STATUS_NO_MEDIA_IN_DEVICE;
 
    /* else we're done! */
    return STATUS_SUCCESS;
}

Referenced by DeviceIoctlPassive(), and ReadWritePassive().

SignalMediaChanged()

VOID NTAPI SignalMediaChanged	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 1128 of file floppy.c.

{
    PDRIVE_INFO DriveInfo = DeviceObject->DeviceExtension;
 
    TRACE_(FLOPPY, "SignalMediaChanged called\n");
 
    DriveInfo->DiskChangeCount++;
 
    /* If volume is not mounted, do NOT set verify and return STATUS_IO_DEVICE_ERROR */
    if(!(DeviceObject->Vpb->Flags & VPB_MOUNTED))
    {
        Irp->IoStatus.Status = STATUS_IO_DEVICE_ERROR;
        Irp->IoStatus.Information = 0;
        return;
    }
 
    /* Notify the filesystem that it will need to verify the volume */
    DeviceObject->Flags |= DO_VERIFY_VOLUME;
    Irp->IoStatus.Status = STATUS_VERIFY_REQUIRED;
    Irp->IoStatus.Information = 0;
 
    /*
     * If this is a user-based, threaded request, let the IO manager know to pop up a box asking
     * the user to supply the correct media, but only if the error (which we just picked out above)
     * is deemed by the IO manager to be "user induced".  The reason we don't just unconditionally
     * call IoSetHardError... is because MS might change the definition of "user induced" some day,
     * and we don't want to have to remember to re-code this.
     */
    if(Irp->Tail.Overlay.Thread && IoIsErrorUserInduced(Irp->IoStatus.Status))
        IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);
}

Referenced by DeviceIoctlPassive(), and ReadWritePassive().

StartMotor()

VOID NTAPI StartMotor

(

PDRIVE_INFO

DriveInfo

)

Definition at line 159 of file floppy.c.

{
    PAGED_CODE();
    ASSERT(DriveInfo);
 
    TRACE_(FLOPPY, "StartMotor called\n");
 
    if(DriveInfo->ControllerInfo->StopDpcQueued && !KeCancelTimer(&DriveInfo->ControllerInfo->MotorTimer))
    {
        /* Motor turner-offer is already running; wait for it to finish */
        INFO_(FLOPPY, "StartMotor: motor turner-offer is already running; waiting for it\n");
        KeWaitForSingleObject(&DriveInfo->ControllerInfo->MotorStoppedEvent, Executive, KernelMode, FALSE, NULL);
        INFO_(FLOPPY, "StartMotor: wait satisfied\n");
    }
 
    DriveInfo->ControllerInfo->StopDpcQueued = FALSE;
 
    if(HwTurnOnMotor(DriveInfo) != STATUS_SUCCESS)
    {
        WARN_(FLOPPY, "StartMotor(): warning: HwTurnOnMotor failed\n");
    }
}

Referenced by AddControllers(), DeviceIoctlPassive(), ReadWritePassive(), Recalibrate(), and ResetChangeFlag().

StopMotor()

VOID NTAPI StopMotor

(

PCONTROLLER_INFO

ControllerInfo

)

Definition at line 198 of file floppy.c.

{
    LARGE_INTEGER StopTime;
 
    ASSERT(ControllerInfo);
 
    TRACE_(FLOPPY, "StopMotor called\n");
 
    /* one relative second, in 100-ns units */
    StopTime.QuadPart = 10000000;
    StopTime.QuadPart *= -1;
 
    KeClearEvent(&ControllerInfo->MotorStoppedEvent);
    KeSetTimer(&ControllerInfo->MotorTimer, StopTime, &ControllerInfo->MotorStopDpc);
    ControllerInfo->StopDpcQueued = TRUE;
}

Referenced by AddControllers(), DeviceIoctlPassive(), ReadWritePassive(), Recalibrate(), and ResetChangeFlag().

Unload()

static VOID NTAPI Unload ( PDRIVER_OBJECT  DriverObject )

static

Definition at line 440 of file floppy.c.

{
    PAGED_CODE();
 
    TRACE_(FLOPPY, "unloading\n");
 
    Cleanup(DriverObject);
}

Referenced by co_IntClientLoadLibrary(), DECLARE_INTERFACE_(), DriverEntry(), IntLoadHookModule(), KdpReportLoadSymbolsStateChange(), KdpSymbol(), and KdpTrap().

WaitForControllerInterrupt()

NTSTATUS NTAPI WaitForControllerInterrupt	(	PCONTROLLER_INFO	ControllerInfo,
		PLARGE_INTEGER	Timeout
	)

Definition at line 226 of file floppy.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
    ASSERT(ControllerInfo);
 
    Status = KeWaitForSingleObject(&ControllerInfo->SynchEvent, Executive, KernelMode, FALSE, Timeout);
    KeClearEvent(&ControllerInfo->SynchEvent);
 
    return Status;
}

Referenced by InitController(), ReadWritePassive(), Recalibrate(), ResetChangeFlag(), RWDetermineMediaType(), and RWSeekToCylinder().

ZwWaitForSingleObject()

NTSYSAPI NTSTATUS NTAPI ZwWaitForSingleObject	(	_In_ HANDLE	Handle,
		_In_ BOOLEAN	Alertable,
		_In_opt_ PLARGE_INTEGER	Timeout
	)

Referenced by DriverEntry(), KmtInitTestFiles(), LsaRegisterLogonProcess(), NpControlPipe(), NpReadPipe(), NpWritePipe(), Phase1InitializationDiscard(), QueryFileInfo(), ScrInbvCleanup(), SepRmCommandServerThreadInit(), START_TEST(), TestAllInformation(), TestSharedCacheMap(), USBPORT_StopWorkerThread(), and WorkerThread().

Variable Documentation

CreateClose

DRIVER_DISPATCH CreateClose

static

Definition at line 251 of file floppy.c.

Referenced by DriverEntry().

gControllerInfo

CONTROLLER_INFO gControllerInfo[MAX_CONTROLLERS]

static

Definition at line 56 of file floppy.c.

Referenced by AddControllers(), Cleanup(), ConfigCallback(), DriverEntry(), and ReportToMountMgr().

gNumberOfControllers

ULONG gNumberOfControllers = 0

static

Definition at line 57 of file floppy.c.

Referenced by AddControllers(), Cleanup(), and ConfigCallback().

QueueThreadObject

PVOID QueueThreadObject

static

Definition at line 69 of file floppy.c.

Referenced by Cleanup(), and DriverEntry().

QueueThreadTerminate

KEVENT QueueThreadTerminate

static

Definition at line 68 of file floppy.c.

Referenced by Cleanup(), DriverEntry(), and QueueThread().