floppy.c File Reference

#include <stddef.h>
#include <ntddk.h>
#include <winerror.h>
#include <scsi.h>
#include <classpnp.h>
#include <initguid.h>
#include <ntddstor.h>
#include <ntstrsafe.h>
#include <intsafe.h>

Include dependency graph for floppy.c:

Go to the source code of this file.

Classes
struct	_DRIVE_MEDIA_LIMITS
struct	_DRIVE_MEDIA_CONSTANTS
struct	_DISK_DATA
struct	_FORMATTED_CAPACITY
struct	_CDB12FORMAT
struct	_DEFECT_LIST_HEADER
struct	_FORMAT_UNIT_PARAMETER_LIST

Macros
#define	MODE_DATA_SIZE   192
#define	SCSI_FLOPPY_TIMEOUT   20
#define	SFLOPPY_SRB_LIST_SIZE   4
#define	NUMBER_OF_DRIVE_TYPES   7
#define	DRIVE_TYPE_120M   4
#define	DRIVE_TYPE_NONE   NUMBER_OF_DRIVE_TYPES
#define	SECTORLENGTHCODE_TO_BYTESHIFT   7
#define	NUMBER_OF_DRIVE_MEDIA_COMBINATIONS   sizeof(DriveMediaConstants)/sizeof(DRIVE_MEDIA_CONSTANTS)
#define	FLOPPY_CAPACITIES   (sizeof(FloppyCapacities)/sizeof(FloppyCapacities[0]))

Typedefs
typedef enum _DRIVE_MEDIA_TYPE	DRIVE_MEDIA_TYPE
typedef struct _DRIVE_MEDIA_LIMITS	DRIVE_MEDIA_LIMITS
typedef struct _DRIVE_MEDIA_LIMITS *	PDRIVE_MEDIA_LIMITS
typedef struct _DRIVE_MEDIA_CONSTANTS	DRIVE_MEDIA_CONSTANTS
typedef struct _DRIVE_MEDIA_CONSTANTS *	PDRIVE_MEDIA_CONSTANTS
typedef struct _DISK_DATA	DISK_DATA
typedef struct _DISK_DATA *	PDISK_DATA
typedef struct _FORMATTED_CAPACITY	FORMATTED_CAPACITY
typedef struct _FORMATTED_CAPACITY *	PFORMATTED_CAPACITY
typedef struct _CDB12FORMAT	CDB12FORMAT
typedef struct _CDB12FORMAT *	PCDB12FORMAT
typedef struct _DEFECT_LIST_HEADER	DEFECT_LIST_HEADER
typedef struct _DEFECT_LIST_HEADER *	PDEFECT_LIST_HEADER
typedef struct _FORMAT_UNIT_PARAMETER_LIST	FORMAT_UNIT_PARAMETER_LIST
typedef struct _FORMAT_UNIT_PARAMETER_LIST *	PFORMAT_UNIT_PARAMETER_LIST

Enumerations
enum	_DRIVE_MEDIA_TYPE {   Drive360Media160 , Drive360Media180 , Drive360Media320 , Drive360Media32X ,   Drive360Media360 , Drive720Media720 , Drive120Media160 , Drive120Media180 ,   Drive120Media320 , Drive120Media32X , Drive120Media360 , Drive120Media120 ,   Drive144Media720 , Drive144Media144 , Drive288Media720 , Drive288Media144 ,   Drive288Media288 , Drive2080Media720 , Drive2080Media144 , Drive2080Media2080 ,   Drive32MMedia32M , Drive120MMedia720 , Drive120MMedia144 , Drive120MMedia120M ,   Drive240MMedia144M , Drive240MMedia120M , Drive240MMedia240M }

Functions
	C_ASSERT ((sizeof(FloppyGeometries)/sizeof(FloppyGeometries[0]))==FLOPPY_CAPACITIES)
NTSTATUS	ScsiFlopInitDevice (IN PDEVICE_OBJECT Fdo)
NTSTATUS	ScsiFlopStartDevice (IN PDEVICE_OBJECT Fdo)
NTSTATUS	ScsiFlopRemoveDevice (IN PDEVICE_OBJECT Fdo, IN UCHAR Type)
NTSTATUS	ScsiFlopStopDevice (IN PDEVICE_OBJECT Fdo, IN UCHAR Type)
BOOLEAN	FindScsiFlops (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath, IN PCLASS_INIT_DATA InitializationData, IN PDEVICE_OBJECT PortDeviceObject, IN ULONG PortNumber)
NTSTATUS	ScsiFlopReadWriteVerification (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	ScsiFlopDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
BOOLEAN	IsFloppyDevice (PDEVICE_OBJECT DeviceObject)
NTSTATUS	CreateFlopDeviceObject (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PortDeviceObject, IN ULONG DeviceCount)
NTSTATUS	DetermineMediaType (PDEVICE_OBJECT DeviceObject)
ULONG	DetermineDriveType (PDEVICE_OBJECT DeviceObject)
BOOLEAN	FlCheckFormatParameters (IN PDEVICE_OBJECT DeviceObject, IN PFORMAT_PARAMETERS FormatParameters)
NTSTATUS	FormatMedia (PDEVICE_OBJECT DeviceObject, MEDIA_TYPE MediaType)
NTSTATUS	FlopticalFormatMedia (PDEVICE_OBJECT DeviceObject, PFORMAT_PARAMETERS Format)
VOID	ScsiFlopProcessError (PDEVICE_OBJECT DeviceObject, PSCSI_REQUEST_BLOCK Srb, NTSTATUS *Status, BOOLEAN *Retry)
NTSTATUS	USBFlopGetMediaTypes (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	USBFlopFormatTracks (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
VOID	ScsiFlopUnload (IN PDRIVER_OBJECT DriverObject)
NTSTATUS	ScsiFlopAddDevice (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT Pdo)
NTSTATUS	ScsiFlopDeviceControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)

Variables
DRIVE_MEDIA_LIMITS	DriveMediaLimits [NUMBER_OF_DRIVE_TYPES]
DRIVE_MEDIA_CONSTANTS	DriveMediaConstants []
FORMATTED_CAPACITY	FloppyCapacities []
DISK_GEOMETRY	FloppyGeometries []
DRIVER_INITIALIZE	DriverEntry
DRIVER_UNLOAD	ScsiFlopUnload
DRIVER_ADD_DEVICE	ScsiFlopAddDevice

Macro Definition Documentation

DRIVE_TYPE_120M

#define DRIVE_TYPE_120M   4

Definition at line 66 of file floppy.c.

DRIVE_TYPE_NONE

#define DRIVE_TYPE_NONE   NUMBER_OF_DRIVE_TYPES

Definition at line 67 of file floppy.c.

FLOPPY_CAPACITIES

#define FLOPPY_CAPACITIES   (sizeof(FloppyCapacities)/sizeof(FloppyCapacities[0]))

Definition at line 298 of file floppy.c.

MODE_DATA_SIZE

#define MODE_DATA_SIZE   192

Definition at line 55 of file floppy.c.

NUMBER_OF_DRIVE_MEDIA_COMBINATIONS

#define NUMBER_OF_DRIVE_MEDIA_COMBINATIONS   sizeof(DriveMediaConstants)/sizeof(DRIVE_MEDIA_CONSTANTS)

Definition at line 220 of file floppy.c.

NUMBER_OF_DRIVE_TYPES

#define NUMBER_OF_DRIVE_TYPES   7

Definition at line 65 of file floppy.c.

SCSI_FLOPPY_TIMEOUT

#define SCSI_FLOPPY_TIMEOUT   20

Definition at line 56 of file floppy.c.

SECTORLENGTHCODE_TO_BYTESHIFT

#define SECTORLENGTHCODE_TO_BYTESHIFT   7

Definition at line 171 of file floppy.c.

SFLOPPY_SRB_LIST_SIZE

#define SFLOPPY_SRB_LIST_SIZE   4

Definition at line 57 of file floppy.c.

Typedef Documentation

CDB12FORMAT

typedef struct _CDB12FORMAT CDB12FORMAT

DEFECT_LIST_HEADER

typedef struct _DEFECT_LIST_HEADER DEFECT_LIST_HEADER

DISK_DATA

typedef struct _DISK_DATA DISK_DATA

DRIVE_MEDIA_CONSTANTS

typedef struct _DRIVE_MEDIA_CONSTANTS DRIVE_MEDIA_CONSTANTS

DRIVE_MEDIA_LIMITS

typedef struct _DRIVE_MEDIA_LIMITS DRIVE_MEDIA_LIMITS

DRIVE_MEDIA_TYPE

typedef enum _DRIVE_MEDIA_TYPE DRIVE_MEDIA_TYPE

FORMAT_UNIT_PARAMETER_LIST

typedef struct _FORMAT_UNIT_PARAMETER_LIST FORMAT_UNIT_PARAMETER_LIST

FORMATTED_CAPACITY

typedef struct _FORMATTED_CAPACITY FORMATTED_CAPACITY

PCDB12FORMAT

typedef struct _CDB12FORMAT * PCDB12FORMAT

PDEFECT_LIST_HEADER

typedef struct _DEFECT_LIST_HEADER * PDEFECT_LIST_HEADER

PDISK_DATA

typedef struct _DISK_DATA * PDISK_DATA

PDRIVE_MEDIA_CONSTANTS

typedef struct _DRIVE_MEDIA_CONSTANTS * PDRIVE_MEDIA_CONSTANTS

PDRIVE_MEDIA_LIMITS

typedef struct _DRIVE_MEDIA_LIMITS * PDRIVE_MEDIA_LIMITS

PFORMAT_UNIT_PARAMETER_LIST

typedef struct _FORMAT_UNIT_PARAMETER_LIST * PFORMAT_UNIT_PARAMETER_LIST

PFORMATTED_CAPACITY

typedef struct _FORMATTED_CAPACITY * PFORMATTED_CAPACITY

Enumeration Type Documentation

_DRIVE_MEDIA_TYPE

enum _DRIVE_MEDIA_TYPE

Enumerator
Drive360Media160
Drive360Media180
Drive360Media320
Drive360Media32X
Drive360Media360
Drive720Media720
Drive120Media160
Drive120Media180
Drive120Media320
Drive120Media32X
Drive120Media360
Drive120Media120
Drive144Media720
Drive144Media144
Drive288Media720
Drive288Media144
Drive288Media288
Drive2080Media720
Drive2080Media144
Drive2080Media2080
Drive32MMedia32M
Drive120MMedia720
Drive120MMedia144
Drive120MMedia120M
Drive240MMedia144M
Drive240MMedia120M
Drive240MMedia240M

Definition at line 80 of file floppy.c.

                               {
    Drive360Media160,                      // 5.25"  360k  drive;  160k   media
    Drive360Media180,                      // 5.25"  360k  drive;  180k   media
    Drive360Media320,                      // 5.25"  360k  drive;  320k   media
    Drive360Media32X,                      // 5.25"  360k  drive;  320k 1k secs
    Drive360Media360,                      // 5.25"  360k  drive;  360k   media
    Drive720Media720,                      // 3.5"   720k  drive;  720k   media
    Drive120Media160,                      // 5.25" 1.2Mb  drive;  160k   media
    Drive120Media180,                      // 5.25" 1.2Mb  drive;  180k   media
    Drive120Media320,                      // 5.25" 1.2Mb  drive;  320k   media
    Drive120Media32X,                      // 5.25" 1.2Mb  drive;  320k 1k secs
    Drive120Media360,                      // 5.25" 1.2Mb  drive;  360k   media
    Drive120Media120,                      // 5.25" 1.2Mb  drive; 1.2Mb   media
    Drive144Media720,                      // 3.5"  1.44Mb drive;  720k   media
    Drive144Media144,                      // 3.5"  1.44Mb drive; 1.44Mb  media
    Drive288Media720,                      // 3.5"  2.88Mb drive;  720k   media
    Drive288Media144,                      // 3.5"  2.88Mb drive; 1.44Mb  media
    Drive288Media288,                      // 3.5"  2.88Mb drive; 2.88Mb  media
    Drive2080Media720,                     // 3.5"  20.8Mb drive;  720k   media
    Drive2080Media144,                     // 3.5"  20.8Mb drive; 1.44Mb  media
    Drive2080Media2080,                    // 3.5"  20.8Mb drive; 20.8Mb  media
    Drive32MMedia32M,                      // 3.5"  32Mb drive; 32MB    media
    Drive120MMedia720,                     // 3.5"  120Mb drive; 720k  media
    Drive120MMedia144,                     // 3.5"  120Mb drive; 1.44Mb  media
    Drive120MMedia120M,                    // 3.5"  120Mb drive; 120Mb  media
    Drive240MMedia144M,                    // 3.5"  240Mb drive; 1.44Mb  media
    Drive240MMedia120M,                    // 3.5"  240Mb drive; 120Mb  media
    Drive240MMedia240M                     // 3.5"  240Mb drive; 240Mb  media
} DRIVE_MEDIA_TYPE;

Function Documentation

C_ASSERT()

C_ASSERT

(

(sizeof(FloppyGeometries)/sizeof(FloppyGeometries[0]))

= =FLOPPY_CAPACITIES

)

CreateFlopDeviceObject()

NTSTATUS CreateFlopDeviceObject	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT	PortDeviceObject,
		IN ULONG	DeviceCount
	)

Definition at line 651 of file floppy.c.

{
    NTSTATUS        status;
    PDEVICE_OBJECT  deviceObject = NULL;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = NULL;
    PDISK_DATA  diskData;
 
    PAGED_CODE();
 
    DebugPrint((3,"CreateFlopDeviceObject: Enter routine\n"));
 
    //
    // Try to claim the device.
    //
 
    status = ClassClaimDevice(Pdo,FALSE);
 
    if (!NT_SUCCESS(status)) {
        return(status);
    }
 
    DeviceCount--;
 
    do {
        UCHAR name[256];
 
        //
        // Create device object for this device.
        //
 
        DeviceCount++;
 
        status = RtlStringCbPrintfA((PCCHAR) name,
                                    sizeof(name),
                                    "\\Device\\Floppy%u",
                                    DeviceCount);
        if (NT_SUCCESS(status)) {
 
            status = ClassCreateDeviceObject(DriverObject,
                                             (PCCHAR) name,
                                             Pdo,
                                             TRUE,
                                             &deviceObject);
        }
    } while ((status == STATUS_OBJECT_NAME_COLLISION) ||
             (status == STATUS_OBJECT_NAME_EXISTS));
 
    if (!NT_SUCCESS(status)) {
        DebugPrint((1,"CreateFlopDeviceObjects: Can not create device\n"));
        goto CreateFlopDeviceObjectExit;
    }
 
    //
    // Indicate that IRPs should include MDLs.
    //
 
    deviceObject->Flags |= DO_DIRECT_IO;
 
    fdoExtension = deviceObject->DeviceExtension;
 
    //
    // Back pointer to device object.
    //
 
    fdoExtension->CommonExtension.DeviceObject = deviceObject;
 
    //
    // This is the physical device.
    //
 
    fdoExtension->CommonExtension.PartitionZeroExtension = fdoExtension;
 
    //
    // Reset the drive type.
    //
 
    diskData = (PDISK_DATA) fdoExtension->CommonExtension.DriverData;
    diskData->DriveType = DRIVE_TYPE_NONE;
    diskData->IsDMF = FALSE;
    // diskData->EnableDMF = TRUE;
 
    //
    // Initialize lock count to zero. The lock count is used to
    // disable the ejection mechanism when media is mounted.
    //
 
    fdoExtension->LockCount = 0;
 
    //
    // Save system floppy number
    //
 
    fdoExtension->DeviceNumber = DeviceCount;
 
    //
    // Set the alignment requirements for the device based on the
    // host adapter requirements
    //
 
    if (Pdo->AlignmentRequirement > deviceObject->AlignmentRequirement) {
        deviceObject->AlignmentRequirement = Pdo->AlignmentRequirement;
    }
 
    //
    // Clear the SrbFlags and disable synchronous transfers
    //
 
    fdoExtension->SrbFlags = SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
 
    //
    // Finally, attach to the PDO
    //
 
    fdoExtension->LowerPdo = Pdo;
 
    fdoExtension->CommonExtension.LowerDeviceObject =
        IoAttachDeviceToDeviceStack(deviceObject, Pdo);
 
    if(fdoExtension->CommonExtension.LowerDeviceObject == NULL) {
 
        status = STATUS_UNSUCCESSFUL;
        goto CreateFlopDeviceObjectExit;
    }
 
    deviceObject->StackSize++;
 
    //
    // The device is initialized properly - mark it as such.
    //
 
    deviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 
    return STATUS_SUCCESS;
 
CreateFlopDeviceObjectExit:
 
    if (deviceObject != NULL) {
        IoDeleteDevice(deviceObject);
    }
 
    return status;
 
} // end CreateFlopDeviceObject()

Referenced by ScsiFlopAddDevice().

DetermineDriveType()

ULONG DetermineDriveType

(

PDEVICE_OBJECT

DeviceObject

)

Definition at line 1899 of file floppy.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PVOID modeData;
    PDISK_DATA diskData = (PDISK_DATA) fdoExtension->CommonExtension.DriverData;
    PMODE_FLEXIBLE_DISK_PAGE pageData;
    ULONG length;
    LONG index;
    UCHAR numberOfHeads;
    UCHAR sectorsPerTrack;
    USHORT maximumTrack;
    BOOLEAN applyFix = FALSE;
 
    PAGED_CODE();
 
    if (diskData->DriveType != DRIVE_TYPE_NONE) {
        return(diskData->DriveType);
    }
 
    modeData = ExAllocatePool(NonPagedPoolNxCacheAligned, MODE_DATA_SIZE);
 
    if (modeData == NULL) {
        return(DRIVE_TYPE_NONE);
    }
 
    RtlZeroMemory(modeData, MODE_DATA_SIZE);
 
    length = ClassModeSense(DeviceObject,
                            modeData,
                            MODE_DATA_SIZE,
                            MODE_PAGE_FLEXIBILE);
 
    if (length < sizeof(MODE_PARAMETER_HEADER)) {
 
        //
        // Retry the request one more time
        // in case of a check condition.
        //
        length = ClassModeSense(DeviceObject,
                                modeData,
                                MODE_DATA_SIZE,
                                MODE_PAGE_FLEXIBILE);
 
        if (length < sizeof(MODE_PARAMETER_HEADER)) {
 
            ExFreePool(modeData);
            return(DRIVE_TYPE_NONE);
        }
    }
 
    //
    // Look for the flexible disk mode page.
    //
 
    pageData = ClassFindModePage( modeData,
                                  length,
                                  MODE_PAGE_FLEXIBILE,
                                  TRUE);
 
    //
    // Make sure the page is returned and is large enough.
    //
 
    if ((pageData != NULL) &&
        (pageData->PageLength + 2 >=
         (UCHAR)offsetof(MODE_FLEXIBLE_DISK_PAGE, StartWritePrecom))) {
 
       //
       // Pull out the heads, cylinders, and sectors.
       //
 
       numberOfHeads = pageData->NumberOfHeads;
       maximumTrack = pageData->NumberOfCylinders[1];
       maximumTrack |= pageData->NumberOfCylinders[0] << 8;
       sectorsPerTrack = pageData->SectorsPerTrack;
 
 
       //
       // Convert from number of cylinders to maximum track.
       //
 
       maximumTrack--;
 
       //
       // Search for the maximum supported media. Based on the number of heads,
       // sectors per track and number of cylinders
       //
       for (index = 0; index < NUMBER_OF_DRIVE_MEDIA_COMBINATIONS; index++) {
 
            //
            // Walk the table forward until the drive capacity holds all of the
            // data and the bytes per setor are equal
            //
 
            if (DriveMediaConstants[index].NumberOfHeads == numberOfHeads &&
                DriveMediaConstants[index].MaximumTrack == maximumTrack &&
                DriveMediaConstants[index].SectorsPerTrack ==sectorsPerTrack) {
 
                ExFreePool(modeData);
 
                //
                // index is now a drive media combination.  Compare this to
                // the maximum drive media type in the drive media table.
                //
 
                for (length = 0; length < NUMBER_OF_DRIVE_TYPES; length++) {
 
                    if (DriveMediaLimits[length].HighestDriveMediaType == index) {
                        return(length);
                    }
                }
                return(DRIVE_TYPE_NONE);
           }
       }
 
       // If the maximum track is greater than 8 bits then divide the
       // number of tracks by 3 and multiply the number of heads by 3.
       // This is a special case for the 20.8 MB floppy.
       //
 
       if (!applyFix && maximumTrack >= 0x0100) {
           maximumTrack++;
           maximumTrack /= 3;
           maximumTrack--;
           numberOfHeads *= 3;
       } else {
           ExFreePool(modeData);
           return(DRIVE_TYPE_NONE);
       }
 
    }
 
    ExFreePool(modeData);
    return(DRIVE_TYPE_NONE);
}

Referenced by FlCheckFormatParameters(), ScsiFlopDeviceControl(), and USBFlopGetMediaTypes().

DetermineMediaType()

NTSTATUS DetermineMediaType

(

PDEVICE_OBJECT

DeviceObject

)

Definition at line 1739 of file floppy.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PDISK_GEOMETRY geometry;
    LONG index;
    NTSTATUS status;
 
    PAGED_CODE();
 
    geometry = &(fdoExtension->DiskGeometry);
 
    //
    // Issue ReadCapacity to update device extension
    // with information for current media.
    //
 
    status = ClassReadDriveCapacity(DeviceObject);
 
    if (!NT_SUCCESS(status)) {
 
       //
       // Set the media type to unknow and zero the geometry information.
       //
 
       geometry->MediaType = Unknown;
 
       return status;
 
    }
 
    //
    // Look at the capcity of disk to determine its type.
    //
 
    for (index = NUMBER_OF_DRIVE_MEDIA_COMBINATIONS - 1; index >= 0; index--) {
 
        //
        // Walk the table backward untill the drive capacity holds all of the
        // data and the bytes per setor are equal
        //
 
         if ((ULONG) (DriveMediaConstants[index].NumberOfHeads *
             (DriveMediaConstants[index].MaximumTrack + 1) *
             DriveMediaConstants[index].SectorsPerTrack *
             DriveMediaConstants[index].BytesPerSector) <=
             fdoExtension->CommonExtension.PartitionLength.LowPart &&
             DriveMediaConstants[index].BytesPerSector ==
             geometry->BytesPerSector) {
 
             geometry->MediaType = DriveMediaConstants[index].MediaType;
             geometry->TracksPerCylinder = DriveMediaConstants[index].NumberOfHeads;
             geometry->SectorsPerTrack = DriveMediaConstants[index].SectorsPerTrack;
             geometry->Cylinders.LowPart = DriveMediaConstants[index].MaximumTrack+1;
             break;
         }
    }
 
    if (index == -1) {
 
        //
        // Set the media type to unknow and zero the geometry information.
        //
 
        geometry->MediaType = Unknown;
 
 
    } else {
        //
        // DMF check breaks the insight SCSI floppy, so its disabled for that case
        //
        PDISK_DATA diskData = (PDISK_DATA) fdoExtension->CommonExtension.DriverData;
 
        // if (diskData->EnableDMF == TRUE) {
 
            //
            //check to see if DMF
            //
 
            PSCSI_REQUEST_BLOCK srb;
            PVOID               readData;
 
            //
            // Allocate a Srb for the read command.
            //
 
            readData = ExAllocatePool(NonPagedPoolNx, geometry->BytesPerSector);
            if (readData == NULL) {
                return STATUS_NO_MEMORY;
            }
 
            srb = ExAllocatePool(NonPagedPoolNx, SCSI_REQUEST_BLOCK_SIZE);
 
            if (srb == NULL) {
 
                ExFreePool(readData);
                return STATUS_NO_MEMORY;
            }
 
            RtlZeroMemory(readData, geometry->BytesPerSector);
            RtlZeroMemory(srb, SCSI_REQUEST_BLOCK_SIZE);
 
            srb->CdbLength = 10;
            srb->Cdb[0] = SCSIOP_READ;
            srb->Cdb[5] = 0;
            srb->Cdb[8] = (UCHAR) 1;
 
            //
            // Set timeout value.
            //
 
            srb->TimeOutValue = fdoExtension->TimeOutValue;
 
            //
            // Send the mode select data.
            //
 
            status = ClassSendSrbSynchronous(DeviceObject,
                      srb,
                      readData,
                      geometry->BytesPerSector,
                      FALSE
                      );
 
            if (NT_SUCCESS(status)) {
                char *pchar = (char *)readData;
 
                pchar += 3; //skip 3 bytes jump code
 
                // If the MSDMF3. signature is there then mark it as DMF diskette
                if (RtlCompareMemory(pchar, "MSDMF3.", 7) == 7) {
                    diskData->IsDMF = TRUE;
                }
 
            }
            ExFreePool(readData);
            ExFreePool(srb);
        // }// else
    }
    return status;
}

Referenced by ScsiFlopDeviceControl(), and ScsiFlopStartDevice().

DriverEntry()

NTSTATUS DriverEntry	(	IN PDRIVER_OBJECT	DriverObject,
		IN PUNICODE_STRING	RegistryPath
	)

Definition at line 501 of file floppy.c.

{
    CLASS_INIT_DATA InitializationData;
 
    //
    // Zero InitData
    //
 
    RtlZeroMemory (&InitializationData, sizeof(CLASS_INIT_DATA));
 
    //
    // Set sizes
    //
 
    InitializationData.InitializationDataSize = sizeof(CLASS_INIT_DATA);
    InitializationData.FdoData.DeviceExtensionSize =
        sizeof(FUNCTIONAL_DEVICE_EXTENSION) + sizeof(DISK_DATA);
 
    InitializationData.FdoData.DeviceType = FILE_DEVICE_DISK;
    InitializationData.FdoData.DeviceCharacteristics = FILE_REMOVABLE_MEDIA | FILE_FLOPPY_DISKETTE;
 
    //
    // Set entry points
    //
 
    InitializationData.FdoData.ClassInitDevice = ScsiFlopInitDevice;
    InitializationData.FdoData.ClassStartDevice = ScsiFlopStartDevice;
    InitializationData.FdoData.ClassStopDevice = ScsiFlopStopDevice;
    InitializationData.FdoData.ClassRemoveDevice = ScsiFlopRemoveDevice;
 
    InitializationData.FdoData.ClassReadWriteVerification = ScsiFlopReadWriteVerification;
    InitializationData.FdoData.ClassDeviceControl = ScsiFlopDeviceControl;
 
    InitializationData.FdoData.ClassShutdownFlush = NULL;
    InitializationData.FdoData.ClassCreateClose = NULL;
    InitializationData.FdoData.ClassError = ScsiFlopProcessError;
    InitializationData.ClassStartIo = NULL;
 
    InitializationData.ClassAddDevice = ScsiFlopAddDevice;
    InitializationData.ClassUnload = ScsiFlopUnload;
    //
    // Call the class init routine
    //
 
    return ClassInitialize( DriverObject, RegistryPath, &InitializationData);
 
 
} // end DriverEntry()

FindScsiFlops()

BOOLEAN FindScsiFlops	(	IN PDRIVER_OBJECT	DriverObject,
		IN PUNICODE_STRING	RegistryPath,
		IN PCLASS_INIT_DATA	InitializationData,
		IN PDEVICE_OBJECT	PortDeviceObject,
		IN ULONG	PortNumber
	)

FlCheckFormatParameters()

BOOLEAN FlCheckFormatParameters	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PFORMAT_PARAMETERS	FormatParameters
	)

Definition at line 2056 of file floppy.c.

{
    PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
    DRIVE_MEDIA_TYPE driveMediaType;
    ULONG index;
 
    PAGED_CODE();
 
    //
    // Get the device type.
    //
 
    index = DetermineDriveType(DeviceObject);
 
    if (index == DRIVE_TYPE_NONE) {
 
        //
        // If the determine device type failed then just use the media type
        // and try the parameters.
        //
 
        driveMediaType = Drive360Media160;
 
        while (( DriveMediaConstants[driveMediaType].MediaType !=
               FormatParameters->MediaType ) &&
               ( driveMediaType < Drive288Media288) ) {
 
               driveMediaType++;
        }
 
    } else {
 
        //
        // Figure out which entry in the DriveMediaConstants table to use.
        //
 
        driveMediaType =
            DriveMediaLimits[index].HighestDriveMediaType;
 
        while ( ( DriveMediaConstants[driveMediaType].MediaType !=
            FormatParameters->MediaType ) &&
            ( driveMediaType > DriveMediaLimits[index].
            LowestDriveMediaType ) ) {
 
            driveMediaType--;
        }
 
    }
 
 
     // driveMediaType is bounded below by DriveMediaLimits[].LowestDriveMediaType
#if !defined(__REACTOS__) || defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:33010) // 33010: Enum used as array index may be negative
#endif
    if ( DriveMediaConstants[driveMediaType].MediaType !=
        FormatParameters->MediaType ) {
        return FALSE;
 
    } else {
 
        driveMediaConstants = &DriveMediaConstants[driveMediaType];
 
        if ( ( FormatParameters->StartHeadNumber >
            (ULONG)( driveMediaConstants->NumberOfHeads - 1 ) ) ||
            ( FormatParameters->EndHeadNumber >
            (ULONG)( driveMediaConstants->NumberOfHeads - 1 ) ) ||
            ( FormatParameters->StartCylinderNumber >
            driveMediaConstants->MaximumTrack ) ||
            ( FormatParameters->EndCylinderNumber >
            driveMediaConstants->MaximumTrack ) ||
            ( FormatParameters->EndCylinderNumber <
            FormatParameters->StartCylinderNumber ) ) {
 
            return FALSE;
 
        } else {
 
            return TRUE;
        }
    }
#if !defined(__REACTOS__) || defined(_MSC_VER)
#pragma warning(pop)
#endif
}

Referenced by ScsiFlopDeviceControl().

FlopticalFormatMedia()

NTSTATUS FlopticalFormatMedia	(	PDEVICE_OBJECT	DeviceObject,
		PFORMAT_PARAMETERS	Format
	)

Definition at line 2682 of file floppy.c.

{
    IO_STATUS_BLOCK ioStatus;
    PIRP irp;
    KEVENT event;
    LARGE_INTEGER offset;
    ULONG length;
    PVOID buffer;
    PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
    NTSTATUS status;
 
    PAGED_CODE();
 
    driveMediaConstants = &DriveMediaConstants[Drive2080Media2080];
 
    //
    // Calculate the length of the buffer.
    //
 
    length = ((Format->EndCylinderNumber - Format->StartCylinderNumber) *
        driveMediaConstants->NumberOfHeads +
        Format->EndHeadNumber - Format->StartHeadNumber + 1) *
        driveMediaConstants->SectorsPerTrack *
        driveMediaConstants->BytesPerSector;
 
    buffer = ExAllocatePool(NonPagedPoolNxCacheAligned, length);
 
    if (buffer == NULL) {
        return(STATUS_INSUFFICIENT_RESOURCES);
    }
 
    RtlZeroMemory(buffer, length);
 
    offset.QuadPart =
    (Format->StartCylinderNumber * driveMediaConstants->NumberOfHeads +
    Format->StartHeadNumber) * driveMediaConstants->SectorsPerTrack *
    driveMediaConstants->BytesPerSector;
 
    //
    // Set the event object to the unsignaled state.
    // It will be used to signal request completion.
    //
 
    KeInitializeEvent(&event, NotificationEvent, FALSE);
 
    //
    // Build the synchronous request with data transfer.
    //
 
    irp = IoBuildSynchronousFsdRequest(
       IRP_MJ_WRITE,
       DeviceObject,
       buffer,
       length,
       &offset,
       &event,
       &ioStatus);
 
    if (irp != NULL) {
        status = IoCallDriver(DeviceObject, irp);
 
        if (status == STATUS_PENDING) {
 
            //
            // Wait for the request to complete if necessary.
            //
 
            KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        }
 
        //
        // If the call  driver suceeded then set the status to the status block.
        //
 
        if (NT_SUCCESS(status)) {
            status = ioStatus.Status;
        }
    } else {
       status = STATUS_INSUFFICIENT_RESOURCES;
    }
 
    ExFreePool(buffer);
 
    return(status);
 
}

Referenced by ScsiFlopDeviceControl().

FormatMedia()

NTSTATUS FormatMedia	(	PDEVICE_OBJECT	DeviceObject,
		MEDIA_TYPE	MediaType
	)

Definition at line 2167 of file floppy.c.

{
    PVOID modeData;
    PSCSI_REQUEST_BLOCK srb;
    PMODE_FLEXIBLE_DISK_PAGE pageData;
    DRIVE_MEDIA_TYPE driveMediaType;
    PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
    ULONG length;
    NTSTATUS status;
 
    PAGED_CODE();
 
    modeData = ExAllocatePool(NonPagedPoolNxCacheAligned, MODE_DATA_SIZE);
 
    if (modeData == NULL) {
        return(STATUS_INSUFFICIENT_RESOURCES);
    }
 
    RtlZeroMemory(modeData, MODE_DATA_SIZE);
 
    length = ClassModeSense(DeviceObject,
                            modeData,
                            MODE_DATA_SIZE,
                            MODE_PAGE_FLEXIBILE);
 
    if (length < sizeof(MODE_PARAMETER_HEADER)) {
        ExFreePool(modeData);
        return(STATUS_INVALID_DEVICE_REQUEST);
    }
 
    //
    // Look for the flexible disk mode page.
    //
 
    pageData = ClassFindModePage( modeData, length, MODE_PAGE_FLEXIBILE, TRUE);
 
    //
    // Make sure the page is returned and is large enough.
    //
 
    if ((pageData == NULL) ||
        (pageData->PageLength + 2 <
         (UCHAR)offsetof(MODE_FLEXIBLE_DISK_PAGE, StartWritePrecom))) {
 
        ExFreePool(modeData);
        return(STATUS_INVALID_DEVICE_REQUEST);
 
    }
 
    //
    // Look for a drive media type which matches the requested media type.
    //
    //
    //start from Drive120MMedia120M instead of Drive2080Media2080
    //
    for (driveMediaType = Drive120MMedia120M;
    DriveMediaConstants[driveMediaType].MediaType != MediaType;
    driveMediaType--) {
         if (driveMediaType == Drive360Media160) {
 
             ExFreePool(modeData);
             return(STATUS_INVALID_PARAMETER);
 
         }
    }
 
    driveMediaConstants = &DriveMediaConstants[driveMediaType];
 
    if ((pageData->NumberOfHeads != driveMediaConstants->NumberOfHeads) ||
        (pageData->SectorsPerTrack != driveMediaConstants->SectorsPerTrack) ||
        ((pageData->NumberOfCylinders[0] != (UCHAR)((driveMediaConstants->MaximumTrack+1) >> 8)) &&
         (pageData->NumberOfCylinders[1] != (UCHAR)driveMediaConstants->MaximumTrack+1)) ||
        (pageData->BytesPerSector[0] != driveMediaConstants->BytesPerSector >> 8 )) {
 
        //
        // Update the flexible parameters page with the new parameters.
        //
 
        pageData->NumberOfHeads = driveMediaConstants->NumberOfHeads;
        pageData->SectorsPerTrack = driveMediaConstants->SectorsPerTrack;
        pageData->NumberOfCylinders[0] = (UCHAR)((driveMediaConstants->MaximumTrack+1) >> 8);
        pageData->NumberOfCylinders[1] = (UCHAR)driveMediaConstants->MaximumTrack+1;
        pageData->BytesPerSector[0] = driveMediaConstants->BytesPerSector >> 8;
 
        //
        // Clear the mode parameter header.
        //
 
        RtlZeroMemory(modeData, sizeof(MODE_PARAMETER_HEADER));
 
        //
        // Set the length equal to the length returned for the flexible page.
        //
 
        length = pageData->PageLength + 2;
 
        //
        // Copy the page after the mode parameter header.
        //
 
        RtlMoveMemory((PCHAR) modeData + sizeof(MODE_PARAMETER_HEADER),
                pageData,
                length
                );
            length += sizeof(MODE_PARAMETER_HEADER);
 
 
        //
        // Allocate a Srb for the format command.
        //
 
        srb = ExAllocatePool(NonPagedPoolNx, SCSI_REQUEST_BLOCK_SIZE);
 
        if (srb == NULL) {
 
            ExFreePool(modeData);
            return(STATUS_INSUFFICIENT_RESOURCES);
        }
 
        RtlZeroMemory(srb, SCSI_REQUEST_BLOCK_SIZE);
 
        srb->CdbLength = 6;
        srb->Cdb[0] = SCSIOP_MODE_SELECT;
        srb->Cdb[4] = (UCHAR) length;
 
        //
        // Set the PF bit.
        //
 
        srb->Cdb[1] |= 0x10;
 
        //
        // Set timeout value.
        //
 
        srb->TimeOutValue = 2;
 
        //
        // Send the mode select data.
        //
 
        status = ClassSendSrbSynchronous(DeviceObject,
                  srb,
                  modeData,
                  length,
                  TRUE
                  );
 
        //
        // The mode data not needed any more so free it.
        //
 
        ExFreePool(modeData);
 
        if (!NT_SUCCESS(status)) {
            ExFreePool(srb);
            return(status);
        }
 
    } else {
 
        //
        // The mode data not needed any more so free it.
        //
 
        ExFreePool(modeData);
 
        //
        // Allocate a Srb for the format command.
        //
 
        srb = ExAllocatePool(NonPagedPoolNx, SCSI_REQUEST_BLOCK_SIZE);
 
        if (srb == NULL) {
            return(STATUS_INSUFFICIENT_RESOURCES);
        }
 
    }
 
    RtlZeroMemory(srb, SCSI_REQUEST_BLOCK_SIZE);
 
    srb->CdbLength = 6;
 
    srb->Cdb[0] = SCSIOP_FORMAT_UNIT;
 
    //
    // Set timeout value.
    //
 
    srb->TimeOutValue = 10 * 60;
 
    status = ClassSendSrbSynchronous(DeviceObject,
                                     srb,
                                     NULL,
                                     0,
                                     FALSE
                                     );
    ExFreePool(srb);
 
    return(status);
 
}

Referenced by ScsiFlopDeviceControl().

IsFloppyDevice()

BOOLEAN IsFloppyDevice

(

PDEVICE_OBJECT

DeviceObject

)

Referenced by ScsiFlopInitDevice().

ScsiFlopAddDevice()

NTSTATUS ScsiFlopAddDevice	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT	Pdo
	)

Definition at line 603 of file floppy.c.

{
    NTSTATUS status;
    ULONG floppyCount = IoGetConfigurationInformation()->FloppyCount;
 
    PAGED_CODE();
 
    //
    // Get the number of disks already initialized.
    //
 
    status = CreateFlopDeviceObject(DriverObject, Pdo, floppyCount);
 
    if (NT_SUCCESS(status)) {
 
        //
        // Increment system floppy device count.
        //
 
        IoGetConfigurationInformation()->FloppyCount++;
    }
 
    return status;
}

ScsiFlopDeviceControl() [1/2]

NTSTATUS ScsiFlopDeviceControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Referenced by DriverEntry().

ScsiFlopDeviceControl() [2/2]

NTSTATUS ScsiFlopDeviceControl	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 1127 of file floppy.c.

{
    KIRQL currentIrql;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PSCSI_REQUEST_BLOCK srb;
    PCDB cdb;
    NTSTATUS status;
    PDISK_GEOMETRY outputBuffer;
    ULONG outputBufferLength;
    ULONG i;
    DRIVE_MEDIA_TYPE lowestDriveMediaType;
    DRIVE_MEDIA_TYPE highestDriveMediaType;
    PFORMAT_PARAMETERS formatParameters;
    PMODE_PARAMETER_HEADER modeData;
    ULONG length;
 
    //
    // Initialize the information field
    //
    Irp->IoStatus.Information = 0;
 
    srb = ExAllocatePool(NonPagedPoolNx, SCSI_REQUEST_BLOCK_SIZE);
 
    if (srb == NULL) {
 
        Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
        if (IoIsErrorUserInduced(Irp->IoStatus.Status)) {
 
            IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);
        }
 
        KeRaiseIrql(DISPATCH_LEVEL, &currentIrql);
        ClassReleaseRemoveLock(DeviceObject, Irp);
        ClassCompleteRequest(DeviceObject, Irp, 0);
        KeLowerIrql(currentIrql);
 
        return(STATUS_INSUFFICIENT_RESOURCES);
    }
 
    //
    // Write zeros to Srb.
    //
 
    RtlZeroMemory(srb, SCSI_REQUEST_BLOCK_SIZE);
 
    cdb = (PCDB)srb->Cdb;
 
    switch (irpStack->Parameters.DeviceIoControl.IoControlCode) {
 
 
    case IOCTL_DISK_VERIFY: {
 
       PVERIFY_INFORMATION verifyInfo = Irp->AssociatedIrp.SystemBuffer;
       LARGE_INTEGER byteOffset;
       ULONG         sectorOffset;
       USHORT        sectorCount;
 
       //
       // Validate buffer length.
       //
 
       if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
           sizeof(VERIFY_INFORMATION)) {
 
           status = STATUS_INFO_LENGTH_MISMATCH;
           break;
       }
 
       //
       // Perform a bounds check on the sector range
       //
       if ((verifyInfo->StartingOffset.QuadPart > fdoExtension->CommonExtension.PartitionLength.QuadPart) ||
           (verifyInfo->StartingOffset.QuadPart < 0))
       {
           status = STATUS_NONEXISTENT_SECTOR;
           break;
       }
       else
       {
           ULONGLONG bytesRemaining = fdoExtension->CommonExtension.PartitionLength.QuadPart - verifyInfo->StartingOffset.QuadPart;
 
           if ((ULONGLONG)verifyInfo->Length > bytesRemaining)
           {
               status = STATUS_NONEXISTENT_SECTOR;
               break;
           }
       }
 
       //
       // Verify sectors
       //
 
       srb->CdbLength = 10;
 
       cdb->CDB10.OperationCode = SCSIOP_VERIFY;
 
       //
       // Add disk offset to starting sector.
       //
 
       byteOffset.QuadPart = fdoExtension->CommonExtension.StartingOffset.QuadPart +
                       verifyInfo->StartingOffset.QuadPart;
 
       //
       // Convert byte offset to sector offset.
       //
 
       sectorOffset = (ULONG)(byteOffset.QuadPart >> fdoExtension->SectorShift);
 
       //
       // Convert ULONG byte count to USHORT sector count.
       //
 
       sectorCount = (USHORT)(verifyInfo->Length >> fdoExtension->SectorShift);
 
       //
       // Move little endian values into CDB in big endian format.
       //
 
       cdb->CDB10.LogicalBlockByte0 = ((PFOUR_BYTE)&sectorOffset)->Byte3;
       cdb->CDB10.LogicalBlockByte1 = ((PFOUR_BYTE)&sectorOffset)->Byte2;
       cdb->CDB10.LogicalBlockByte2 = ((PFOUR_BYTE)&sectorOffset)->Byte1;
       cdb->CDB10.LogicalBlockByte3 = ((PFOUR_BYTE)&sectorOffset)->Byte0;
 
       cdb->CDB10.TransferBlocksMsb = ((PFOUR_BYTE)&sectorCount)->Byte1;
       cdb->CDB10.TransferBlocksLsb = ((PFOUR_BYTE)&sectorCount)->Byte0;
 
       //
       // The verify command is used by the NT FORMAT utility and
       // requests are sent down for 5% of the volume size. The
       // request timeout value is calculated based on the number of
       // sectors verified.
       //
 
       srb->TimeOutValue = ((sectorCount + 0x7F) >> 7) *
                             fdoExtension->TimeOutValue;
 
       status = ClassSendSrbAsynchronous(DeviceObject,
                                         srb,
                                         Irp,
                                         NULL,
                                         0,
                                         FALSE);
       return(status);
 
    }
 
    case IOCTL_DISK_GET_PARTITION_INFO: {
 
        if (fdoExtension->AdapterDescriptor->BusType == BusTypeUsb) {
 
            USBFlopGetMediaTypes(DeviceObject, NULL);
 
            // Don't need to propagate any error if one occurs
            //
            status = STATUS_SUCCESS;
 
        } else {
 
            status = DetermineMediaType(DeviceObject);
        }
 
        if (!NT_SUCCESS(status)) {
            // so will propogate error
            NOTHING;
        } else if (fdoExtension->DiskGeometry.MediaType == F3_120M_512) {
            //so that the format code will not try to partition it.
            status = STATUS_INVALID_DEVICE_REQUEST;
        } else {
           //
           // Free the Srb, since it is not needed.
           //
 
           ExFreePool(srb);
 
           //
           // Pass the request to the common device control routine.
           //
 
           return(ClassDeviceControl(DeviceObject, Irp));
        }
        break;
    }
 
    case IOCTL_DISK_GET_DRIVE_GEOMETRY: {
 
        DebugPrint((3,"ScsiDeviceIoControl: Get drive geometry\n"));
 
        if (fdoExtension->AdapterDescriptor->BusType == BusTypeUsb)
        {
            status = USBFlopGetMediaTypes(DeviceObject,
                                          Irp);
            break;
        }
 
        //
        // If there's not enough room to write the
        // data, then fail the request.
        //
 
        if ( irpStack->Parameters.DeviceIoControl.OutputBufferLength <
            sizeof( DISK_GEOMETRY ) ) {
 
            status = STATUS_INVALID_PARAMETER;
            break;
        }
 
        status = DetermineMediaType(DeviceObject);
 
        if (!NT_SUCCESS(status)) {
 
            Irp->IoStatus.Information = 0;
            Irp->IoStatus.Status = status;
 
        } else {
 
            //
            // Copy drive geometry information from device extension.
            //
 
            RtlMoveMemory(Irp->AssociatedIrp.SystemBuffer,
                          &(fdoExtension->DiskGeometry),
                          sizeof(DISK_GEOMETRY));
 
            Irp->IoStatus.Information = sizeof(DISK_GEOMETRY);
            status = STATUS_SUCCESS;
 
        }
 
        break;
    }
 
    case IOCTL_DISK_GET_MEDIA_TYPES: {
 
        if (fdoExtension->AdapterDescriptor->BusType == BusTypeUsb)
        {
            status = USBFlopGetMediaTypes(DeviceObject,
                                          Irp);
            break;
        }
 
        i = DetermineDriveType(DeviceObject);
 
        if (i == DRIVE_TYPE_NONE) {
            status = STATUS_UNRECOGNIZED_MEDIA;
            break;
        }
 
        lowestDriveMediaType = DriveMediaLimits[i].LowestDriveMediaType;
        highestDriveMediaType = DriveMediaLimits[i].HighestDriveMediaType;
 
        outputBufferLength =
        irpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
        //
        // Make sure that the input buffer has enough room to return
        // at least one descriptions of a supported media type.
        //
 
        if ( outputBufferLength < ( sizeof( DISK_GEOMETRY ) ) ) {
 
            status = STATUS_BUFFER_TOO_SMALL;
            break;
        }
 
        //
        // Assume success, although we might modify it to a buffer
        // overflow warning below (if the buffer isn't big enough
        // to hold ALL of the media descriptions).
        //
 
        status = STATUS_SUCCESS;
 
        if (outputBufferLength < ( sizeof( DISK_GEOMETRY ) *
            ( highestDriveMediaType - lowestDriveMediaType + 1 ) ) ) {
 
            //
            // The buffer is too small for all of the descriptions;
            // calculate what CAN fit in the buffer.
            //
 
            status = STATUS_BUFFER_OVERFLOW;
 
            highestDriveMediaType = (DRIVE_MEDIA_TYPE)( ( lowestDriveMediaType - 1 ) +
                ( outputBufferLength /
                sizeof( DISK_GEOMETRY ) ) );
        }
 
        outputBuffer = (PDISK_GEOMETRY) Irp->AssociatedIrp.SystemBuffer;
 
        for (i = (UCHAR)lowestDriveMediaType;i <= (UCHAR)highestDriveMediaType;i++ ) {
 
             outputBuffer->MediaType = DriveMediaConstants[i].MediaType;
             outputBuffer->Cylinders.LowPart =
                 DriveMediaConstants[i].MaximumTrack + 1;
             outputBuffer->Cylinders.HighPart = 0;
             outputBuffer->TracksPerCylinder =
                 DriveMediaConstants[i].NumberOfHeads;
             outputBuffer->SectorsPerTrack =
                 DriveMediaConstants[i].SectorsPerTrack;
             outputBuffer->BytesPerSector =
                 DriveMediaConstants[i].BytesPerSector;
             outputBuffer++;
 
             Irp->IoStatus.Information += sizeof( DISK_GEOMETRY );
        }
 
        break;
    }
 
    case IOCTL_DISK_FORMAT_TRACKS: {
 
        if (fdoExtension->AdapterDescriptor->BusType == BusTypeUsb)
        {
            status = USBFlopFormatTracks(DeviceObject,
                                         Irp);
            break;
        }
 
        //
        // Make sure that we got all the necessary format parameters.
        //
 
        if ( irpStack->Parameters.DeviceIoControl.InputBufferLength <sizeof( FORMAT_PARAMETERS ) ) {
 
            status = STATUS_INVALID_PARAMETER;
            break;
        }
 
        formatParameters = (PFORMAT_PARAMETERS) Irp->AssociatedIrp.SystemBuffer;
 
        //
        // Make sure the parameters we got are reasonable.
        //
 
        if ( !FlCheckFormatParameters(DeviceObject, formatParameters)) {
 
            status = STATUS_INVALID_PARAMETER;
            break;
        }
 
        //
        // If this request is for a 20.8 MB floppy then call a special
        // floppy format routine.
        //
 
        if (formatParameters->MediaType == F3_20Pt8_512) {
            status = FlopticalFormatMedia(DeviceObject,
                                          formatParameters
                                          );
 
            break;
        }
 
        //
        // All the work is done in the pass.  If this is not the first pass,
        // then complete the request and return;
        //
 
        if (formatParameters->StartCylinderNumber != 0 || formatParameters->StartHeadNumber != 0) {
 
            status = STATUS_SUCCESS;
            break;
        }
 
        status = FormatMedia( DeviceObject, formatParameters->MediaType);
        break;
    }
 
    case IOCTL_DISK_IS_WRITABLE: {
 
        if ((fdoExtension->DiskGeometry.MediaType) == F3_32M_512) {
 
            //
            // 32MB media is READ ONLY. Just return
            // STATUS_MEDIA_WRITE_PROTECTED
            //
 
            status = STATUS_MEDIA_WRITE_PROTECTED;
 
            break;
        }
 
        //
        // Determine if the device is writable.
        //
 
        modeData = ExAllocatePool(NonPagedPoolNxCacheAligned, MODE_DATA_SIZE);
 
        if (modeData == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }
 
        RtlZeroMemory(modeData, MODE_DATA_SIZE);
 
        length = ClassModeSense(DeviceObject,
                                (PCHAR) modeData,
                                MODE_DATA_SIZE,
                                MODE_SENSE_RETURN_ALL);
 
        if (length < sizeof(MODE_PARAMETER_HEADER)) {
 
            //
            // Retry the request in case of a check condition.
            //
 
            length = ClassModeSense(DeviceObject,
                                    (PCHAR) modeData,
                                    MODE_DATA_SIZE,
                                    MODE_SENSE_RETURN_ALL);
 
            if (length < sizeof(MODE_PARAMETER_HEADER)) {
                status = STATUS_IO_DEVICE_ERROR;
                ExFreePool(modeData);
                break;
            }
        }
 
        if (modeData->DeviceSpecificParameter & MODE_DSP_WRITE_PROTECT) {
            status = STATUS_MEDIA_WRITE_PROTECTED;
        } else {
            status = STATUS_SUCCESS;
        }
 
        DebugPrint((2,"IOCTL_DISK_IS_WRITABLE returns %08X\n", status));
 
        ExFreePool(modeData);
        break;
    }
 
    default: {
 
        DebugPrint((3,"ScsiIoDeviceControl: Unsupported device IOCTL\n"));
 
        //
        // Free the Srb, since it is not needed.
        //
 
        ExFreePool(srb);
 
        //
        // Pass the request to the common device control routine.
        //
 
        return(ClassDeviceControl(DeviceObject, Irp));
 
        break;
    }
 
    } // end switch( ...
 
    //
    // Check if SL_OVERRIDE_VERIFY_VOLUME flag is set in the IRP.
    // If so, do not return STATUS_VERIFY_REQUIRED
    //
    if ((status == STATUS_VERIFY_REQUIRED) &&
        (TEST_FLAG(irpStack->Flags, SL_OVERRIDE_VERIFY_VOLUME))) {
 
        status = STATUS_IO_DEVICE_ERROR;
 
    }
 
    Irp->IoStatus.Status = status;
 
    if (!NT_SUCCESS(status) && IoIsErrorUserInduced(status)) {
 
        IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);
    }
 
    KeRaiseIrql(DISPATCH_LEVEL, &currentIrql);
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, 0);
    KeLowerIrql(currentIrql);
 
    ExFreePool(srb);
 
    return status;
 
} // end ScsiFlopDeviceControl()

ScsiFlopInitDevice()

NTSTATUS ScsiFlopInitDevice

(

IN PDEVICE_OBJECT

Fdo

)

Definition at line 826 of file floppy.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
    PDISK_DATA diskData = commonExtension->DriverData;
 
    PVOID senseData = NULL;
    ULONG timeOut;
 
    NTSTATUS status = STATUS_SUCCESS;
 
    //
    // Allocate request sense buffer.
    //
 
    senseData = ExAllocatePool(NonPagedPoolNxCacheAligned, SENSE_BUFFER_SIZE);
 
    if (senseData == NULL) {
 
        //
        // The buffer cannot be allocated.
        //
 
        status = STATUS_INSUFFICIENT_RESOURCES;
        return status;
    }
 
    //
    // Set the sense data pointer in the device extension.
    //
 
    fdoExtension->SenseData = senseData;
 
    //
    // Build the lookaside list for srb's for this device.
    //
 
    ClassInitializeSrbLookasideList((PCOMMON_DEVICE_EXTENSION)fdoExtension,
                                    SFLOPPY_SRB_LIST_SIZE);
 
    //
    // Register for media change notification
    //
    ClassInitializeMediaChangeDetection(fdoExtension,
                                        (PUCHAR) "SFloppy");
 
    //
    // Set timeout value in seconds.
    //
 
    timeOut = ClassQueryTimeOutRegistryValue(Fdo);
    if (timeOut) {
        fdoExtension->TimeOutValue = timeOut;
    } else {
        fdoExtension->TimeOutValue = SCSI_FLOPPY_TIMEOUT;
    }
 
    //
    // Floppies are not partitionable so starting offset is 0.
    //
 
    fdoExtension->CommonExtension.StartingOffset.QuadPart = (LONGLONG)0;
 
#if 0
    if (!IsFloppyDevice(Fdo) ||
        !(Fdo->Characteristics & FILE_REMOVABLE_MEDIA) ||
        (fdoExtension->DeviceDescriptor->DeviceType != DIRECT_ACCESS_DEVICE)) {
 
        ExFreePool(senseData);
        status = STATUS_NO_SUCH_DEVICE;
        return status;
    }
#endif
 
    RtlZeroMemory(&(fdoExtension->DiskGeometry),
                  sizeof(DISK_GEOMETRY));
 
    //
    // Determine the media type if possible. Set the current media type to
    // Unknown so that determine media type will check the media.
    //
 
    fdoExtension->DiskGeometry.MediaType = Unknown;
 
    //
    // Register interfaces for this device.
    //
 
    {
        UNICODE_STRING interfaceName;
 
        RtlInitUnicodeString(&interfaceName, NULL);
 
        status = IoRegisterDeviceInterface(fdoExtension->LowerPdo,
                                           (LPGUID) &GUID_DEVINTERFACE_FLOPPY,
                                           NULL,
                                           &interfaceName);
 
        if(NT_SUCCESS(status)) {
            diskData->FloppyInterfaceString = interfaceName;
        } else {
            RtlInitUnicodeString(&(diskData->FloppyInterfaceString), NULL);
            DebugPrint((1, "ScsiFlopStartDevice: Unable to register device "
                           "interface for fdo %p [%08lx]\n",
                        Fdo, status));
        }
    }
 
    return (STATUS_SUCCESS);
}

Referenced by DriverEntry().

ScsiFlopProcessError()

VOID ScsiFlopProcessError	(	PDEVICE_OBJECT	DeviceObject,
		PSCSI_REQUEST_BLOCK	Srb,
		NTSTATUS *	Status,
		BOOLEAN *	Retry
	)

Definition at line 2397 of file floppy.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PDISK_DATA diskData = (PDISK_DATA) fdoExtension->CommonExtension.DriverData;
    PSENSE_DATA senseBuffer = Srb->SenseInfoBuffer;
    PIO_STACK_LOCATION irpStack;
    PIRP irp;
    PSCSI_REQUEST_BLOCK srb;
    LARGE_INTEGER largeInt;
    PCOMPLETION_CONTEXT context;
    PCDB cdb;
    ULONG_PTR alignment;
    ULONG majorFunction;
 
    UNREFERENCED_PARAMETER(Status);
    UNREFERENCED_PARAMETER(Retry);
 
    largeInt.QuadPart = 1;
 
    //
    // Check the status.  The initialization command only needs to be sent
    // if UNIT ATTENTION or LUN NOT READY is returned.
    //
 
    if (!(Srb->SrbStatus & SRB_STATUS_AUTOSENSE_VALID)) {
 
        //
        // The drive does not require reinitialization.
        //
 
        return;
    }
 
    //
    // Reset the drive type.
    //
 
    diskData->DriveType = DRIVE_TYPE_NONE;
    diskData->IsDMF = FALSE;
 
    fdoExtension->DiskGeometry.MediaType = Unknown;
 
    if (fdoExtension->AdapterDescriptor->BusType == BusTypeUsb) {
 
        // FLPYDISK.SYS never returns a non-zero value for the ChangeCount
        // on an IOCTL_DISK_CHECK_VERIFY.  Some things seem to work better
        // if we do the same.  In particular, FatVerifyVolume() can exit between
        // the IOCTL_DISK_CHECK_VERIFY and the IOCTL_DISK_GET_DRIVE_GEOMETRY
        // if a non-zero ChangeCount is returned, and this appears to cause
        // issues formatting unformatted media in some situations.
        //
        // This is something that should probably be revisited at some point.
        //
        fdoExtension->MediaChangeCount = 0;
 
        if (((senseBuffer->SenseKey & 0xf) == SCSI_SENSE_UNIT_ATTENTION) &&
            (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_MEDIUM_CHANGED)) {
 
            struct _START_STOP *startStopCdb;
 
            DebugPrint((2,"Sending SCSIOP_START_STOP_UNIT\n"));
 
            context = ExAllocatePool(NonPagedPoolNx,
                                     sizeof(COMPLETION_CONTEXT));
 
            if (context == NULL) {
 
                return;
            }
#if (NTDDI_VERSION >= NTDDI_WIN8)
            srb = &context->Srb.Srb;
#else
            srb = &context->Srb;
#endif
 
            RtlZeroMemory(srb, SCSI_REQUEST_BLOCK_SIZE);
 
            srb->SrbFlags = SRB_FLAGS_DISABLE_AUTOSENSE;
 
            srb->CdbLength = 6;
 
            startStopCdb = (struct _START_STOP *)srb->Cdb;
 
            startStopCdb->OperationCode = SCSIOP_START_STOP_UNIT;
            startStopCdb->Start = 1;
 
            // A Start Stop Unit request has no transfer buffer.
            // Set the request to IRP_MJ_FLUSH_BUFFERS when calling
            // IoBuildAsynchronousFsdRequest() so that it ignores
            // the buffer pointer and buffer length parameters.
            //
            majorFunction = IRP_MJ_FLUSH_BUFFERS;
 
        } else if ((senseBuffer->SenseKey & 0xf) == SCSI_SENSE_MEDIUM_ERROR) {
 
            // Return ERROR_UNRECOGNIZED_MEDIA instead of
            // STATUS_DEVICE_DATA_ERROR to make shell happy.
            //
            *Status = STATUS_UNRECOGNIZED_MEDIA;
            return;
 
        } else {
 
            return;
        }
 
#ifndef __REACTOS__
    } else if (((senseBuffer->SenseKey & 0xf) == SCSI_SENSE_NOT_READY) &&
             senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_INIT_COMMAND_REQUIRED ||
             (senseBuffer->SenseKey & 0xf) == SCSI_SENSE_UNIT_ATTENTION) {
#else
    } else if ((((senseBuffer->SenseKey & 0xf) == SCSI_SENSE_NOT_READY) &&
             senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_INIT_COMMAND_REQUIRED) ||
             (senseBuffer->SenseKey & 0xf) == SCSI_SENSE_UNIT_ATTENTION) {
#endif
 
        ULONG sizeNeeded;
        ULONG tmpSize;
        BOOLEAN overFlow;
 
        DebugPrint((1, "ScsiFlopProcessError: Reinitializing the floppy.\n"));
 
        //
        // Send the special mode sense command to enable writes on the
        // floptical drive.
        //
 
        alignment = DeviceObject->AlignmentRequirement ?
            DeviceObject->AlignmentRequirement : 1;
 
        sizeNeeded = 0;
        overFlow = TRUE;
        if (SUCCEEDED(ULongAdd(sizeof(COMPLETION_CONTEXT), 0x2a, &tmpSize))) {
 
            if (SUCCEEDED(ULongAdd(tmpSize, (ULONG) alignment, &sizeNeeded))) {
                overFlow = FALSE;
            }
        }
 
        context = NULL;
 
        if (!overFlow) {
            context = ExAllocatePool(NonPagedPoolNx, sizeNeeded);
        }
 
        if (context == NULL) {
 
            //
            // If there is not enough memory to fulfill this request,
            // simply return. A subsequent retry will fail and another
            // chance to start the unit.
            //
 
            return;
        }
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
        srb = &context->Srb.Srb;
#else
        srb = &context->Srb;
#endif
 
        RtlZeroMemory(srb, SCSI_REQUEST_BLOCK_SIZE);
 
        //
        // Set the transfer length.
        //
 
        srb->DataTransferLength = 0x2a;
        srb->SrbFlags = SRB_FLAGS_DATA_IN | SRB_FLAGS_DISABLE_AUTOSENSE | SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
 
        //
        // The data buffer must be aligned.
        //
 
        srb->DataBuffer = (PVOID) (((ULONG_PTR) (context + 1) + (alignment - 1)) &
            ~(alignment - 1));
 
 
        //
        // Build the start unit CDB.
        //
 
        srb->CdbLength = 6;
        cdb = (PCDB)srb->Cdb;
        cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
        cdb->MODE_SENSE.PageCode = 0x2e;
        cdb->MODE_SENSE.AllocationLength = 0x2a;
 
        majorFunction = IRP_MJ_READ;
 
    } else {
 
        return;
    }
 
    context->DeviceObject = DeviceObject;
 
    //
    // Write length to SRB.
    //
 
    srb->Length = SCSI_REQUEST_BLOCK_SIZE;
 
    srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
    srb->TimeOutValue = fdoExtension->TimeOutValue;
 
    //
    // Build the asynchronous request
    // to be sent to the port driver.
    //
 
    irp = IoBuildAsynchronousFsdRequest(majorFunction,
                       DeviceObject,
                       srb->DataBuffer,
                       srb->DataTransferLength,
                       &largeInt,
                       NULL);
 
    if(irp == NULL) {
        ExFreePool(context);
        return;
    }
 
 
    IoSetCompletionRoutine(irp,
           (PIO_COMPLETION_ROUTINE)ClassAsynchronousCompletion,
           context,
           TRUE,
           TRUE,
           TRUE);
 
    ClassAcquireRemoveLock(DeviceObject, irp);
 
    irpStack = IoGetNextIrpStackLocation(irp);
 
    irpStack->MajorFunction = IRP_MJ_SCSI;
 
    srb->OriginalRequest = irp;
 
    //
    // Save SRB address in next stack for port driver.
    //
 
    irpStack->Parameters.Others.Argument1 = (PVOID)srb;
 
    //
    // Can't release the remove lock yet - let ClassAsynchronousCompletion
    // take care of that for us.
    //
 
    (VOID)IoCallDriver(fdoExtension->CommonExtension.LowerDeviceObject, irp);
 
    return;
}

Referenced by DriverEntry().

ScsiFlopReadWriteVerification()

NTSTATUS ScsiFlopReadWriteVerification	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 1087 of file floppy.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS status = STATUS_SUCCESS;
 
    //
    // Make sure that the number of bytes to transfer is a multiple of the sector size
    //
    if ((irpSp->Parameters.Read.Length & (fdoExtension->DiskGeometry.BytesPerSector - 1)) != 0)
    {
        status = STATUS_INVALID_PARAMETER;
    }
 
    Irp->IoStatus.Status = status;
 
    return status;
}

Referenced by DriverEntry().

ScsiFlopRemoveDevice()

NTSTATUS ScsiFlopRemoveDevice	(	IN PDEVICE_OBJECT	Fdo,
		IN UCHAR	Type
	)

Definition at line 2796 of file floppy.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION deviceExtension =
        DeviceObject->DeviceExtension;
    PDISK_DATA diskData = deviceExtension->CommonExtension.DriverData;
    NTSTATUS status;
 
    PAGED_CODE();
 
    if((Type == IRP_MN_QUERY_REMOVE_DEVICE) ||
       (Type == IRP_MN_CANCEL_REMOVE_DEVICE)) {
        return STATUS_SUCCESS;
    }
 
    if (Type == IRP_MN_REMOVE_DEVICE){
        if(deviceExtension->DeviceDescriptor) {
            ExFreePool(deviceExtension->DeviceDescriptor);
            deviceExtension->DeviceDescriptor = NULL;
        }
 
        if(deviceExtension->AdapterDescriptor) {
            ExFreePool(deviceExtension->AdapterDescriptor);
            deviceExtension->AdapterDescriptor = NULL;
        }
 
        if(deviceExtension->SenseData) {
            ExFreePool(deviceExtension->SenseData);
            deviceExtension->SenseData = NULL;
        }
 
        ClassDeleteSrbLookasideList(&deviceExtension->CommonExtension);
    }
 
    if(diskData->FloppyInterfaceString.Buffer != NULL) {
 
        status = IoSetDeviceInterfaceState(
                   &(diskData->FloppyInterfaceString),
                   FALSE);
 
        if (!NT_SUCCESS(status)) {
            // Failed to disable device interface during removal. Not a fatal error.
            DebugPrint((1, "ScsiFlopRemoveDevice: Unable to set device "
                           "interface state to FALSE for fdo %p "
                           "[%08lx]\n",
                        DeviceObject, status));
        }
 
        RtlFreeUnicodeString(&(diskData->FloppyInterfaceString));
        RtlInitUnicodeString(&(diskData->FloppyInterfaceString), NULL);
    }
 
    if(Type == IRP_MN_REMOVE_DEVICE) {
        IoGetConfigurationInformation()->FloppyCount--;
    }
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

ScsiFlopStartDevice()

NTSTATUS ScsiFlopStartDevice

(

IN PDEVICE_OBJECT

Fdo

)

Definition at line 945 of file floppy.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
 
    PIRP        irp;
    IO_STATUS_BLOCK ioStatus;
 
    SCSI_ADDRESS    scsiAddress;
 
    WCHAR   ntNameBuffer[256];
    UNICODE_STRING  ntUnicodeString;
 
    WCHAR   arcNameBuffer[256];
    UNICODE_STRING  arcUnicodeString;
 
    KEVENT event;
 
    NTSTATUS status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    KeInitializeEvent(&event,SynchronizationEvent,FALSE);
 
    DetermineMediaType(Fdo); // ignore unsuccessful here
 
    //
    // Create device object for this device.
    //
 
    RtlStringCbPrintfW(ntNameBuffer,
                       sizeof(ntNameBuffer),
                       L"\\Device\\Floppy%u",
                       fdoExtension->DeviceNumber);
 
    //
    // Create local copy of unicode string
    //
    RtlInitUnicodeString(&ntUnicodeString,ntNameBuffer);
 
    //
    // Create a symbolic link from the disk name to the corresponding
    // ARC name, to be used if we're booting off the disk.  This will
    // fail if it's not system initialization time; that's fine.  The
    // ARC name looks something like \ArcName\scsi(0)Flop(0)fdisk(0).
    // In order to get the address, we need to send a IOCTL_SCSI_GET_ADDRESS...
    //
 
    irp = IoBuildDeviceIoControlRequest(IOCTL_SCSI_GET_ADDRESS,
                                        Fdo,
                                        NULL,
                                        0,
                                        &scsiAddress,
                                        sizeof(scsiAddress),
                                        FALSE,
                                        &event,
                                        &ioStatus);
 
    if (irp == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    status = IoCallDriver(fdoExtension->CommonExtension.LowerDeviceObject, irp);
 
    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }
 
    //
    // IOCTL_SCSI_GET_ADDRESS might not be supported by the port driver and
    // hence may fail. But it is not a fatal error. Do not fail PnP start
    // if this IOCTL fails.
    //
    if (NT_SUCCESS(status)) {
 
        RtlStringCbPrintfW(arcNameBuffer,
                           sizeof(arcNameBuffer),
                           L"\\ArcName\\scsi(%u)disk(%u)fdisk(%u)",
                           scsiAddress.PortNumber,
                           scsiAddress.TargetId,
                           scsiAddress.Lun);
 
        RtlInitUnicodeString(&arcUnicodeString, arcNameBuffer);
 
        IoAssignArcName(&arcUnicodeString, &ntUnicodeString);
    }
 
    status = STATUS_SUCCESS;
 
    //
    // Create the multi() arc name -- Create the "fake"
    // name of multi(0)disk(0)fdisk(#) to handle the case where the
    // SCSI floppy is the only floppy in the system.  If this fails
    // it doesn't matter because the previous scsi() based ArcName
    // will work.  This name is necessary for installation.
    //
 
    RtlStringCbPrintfW(arcNameBuffer,
                       sizeof(arcNameBuffer),
                       L"\\ArcName\\multi(%u)disk(%u)fdisk(%u)",
                       0,
                       0,
                       fdoExtension->DeviceNumber);
 
    RtlInitUnicodeString(&arcUnicodeString, arcNameBuffer);
 
    IoAssignArcName(&arcUnicodeString, &ntUnicodeString);
 
    //
    // Set our interface state.
    //
 
    {
        PDISK_DATA diskData = commonExtension->DriverData;
 
        if(diskData->FloppyInterfaceString.Buffer != NULL) {
 
            status = IoSetDeviceInterfaceState(
                        &(diskData->FloppyInterfaceString),
                        TRUE);
 
            if(!NT_SUCCESS(status)) {
                DebugPrint((1, "ScsiFlopStartDevice: Unable to set device "
                               "interface state to TRUE for fdo %p "
                               "[%08lx]\n",
                            Fdo, status));
            }
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

ScsiFlopStopDevice()

NTSTATUS ScsiFlopStopDevice	(	IN PDEVICE_OBJECT	Fdo,
		IN UCHAR	Type
	)

Definition at line 2886 of file floppy.c.

{
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(Type);
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

ScsiFlopUnload()

VOID ScsiFlopUnload

(

IN PDRIVER_OBJECT

DriverObject

)

Definition at line 574 of file floppy.c.

{
    PAGED_CODE();
    UNREFERENCED_PARAMETER(DriverObject);
    return;
}

USBFlopFormatTracks()

NTSTATUS USBFlopFormatTracks	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 3269 of file floppy.c.

{
/*++
 
Routine Description:
 
    This routines formats the specified tracks.  If multiple tracks are
    specified, each is formatted with a separate Format Unit request.
 
Arguments:
 
    DeviceObject - Supplies the device object.
 
    Irp - A IOCTL_DISK_FORMAT_TRACKS Irp.
 
Return Value:
 
    Status is returned.
 
--*/
    PFUNCTIONAL_DEVICE_EXTENSION    fdoExtension;
    PIO_STACK_LOCATION              irpStack;
    PFORMAT_PARAMETERS              formatParameters;
    PDISK_GEOMETRY                  geometry;
    PFORMATTED_CAPACITY             capacity;
    PSCSI_REQUEST_BLOCK             srb;
    PFORMAT_UNIT_PARAMETER_LIST     parameterList;
    PCDB12FORMAT                    cdb;
    ULONG                           i;
    ULONG                           cylinder, head;
    NTSTATUS                        status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    fdoExtension = DeviceObject->DeviceExtension;
 
    // Get the Irp parameters
    //
    irpStack = IoGetCurrentIrpStackLocation(Irp);
 
    if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
        sizeof(FORMAT_PARAMETERS))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    formatParameters = (PFORMAT_PARAMETERS)Irp->AssociatedIrp.SystemBuffer;
 
    // Find the geometry / capacity entries corresponding to the format
    // parameters MediaType
    //
    geometry = NULL;
    capacity = NULL;
 
    for (i=0; i<FLOPPY_CAPACITIES; i++)
    {
        if (FloppyGeometries[i].MediaType == formatParameters->MediaType)
        {
            geometry = &FloppyGeometries[i];
            capacity = &FloppyCapacities[i];
 
            break;
        }
    }
 
    if (geometry == NULL)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    // Check if the format parameters are valid
    //
    if ((formatParameters->StartCylinderNumber >
         geometry->Cylinders.LowPart - 1)       ||
 
        (formatParameters->EndCylinderNumber >
         geometry->Cylinders.LowPart - 1)       ||
 
        (formatParameters->StartHeadNumber >
         geometry->TracksPerCylinder - 1)       ||
 
        (formatParameters->EndHeadNumber >
         geometry->TracksPerCylinder - 1)       ||
 
        (formatParameters->StartCylinderNumber >
         formatParameters->EndCylinderNumber)   ||
 
        (formatParameters->StartHeadNumber >
         formatParameters->EndHeadNumber))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    // Don't low level format LS-120 media, Imation says it's best to not
    // do this.
    //
    if ((formatParameters->MediaType == F3_120M_512) ||
        (formatParameters->MediaType == F3_240M_512) ||
        (formatParameters->MediaType == F3_32M_512))
    {
        return STATUS_SUCCESS;
    }
 
    // Allocate an SRB for the SCSIOP_FORMAT_UNIT request
    //
    srb = ExAllocatePool(NonPagedPoolNx, SCSI_REQUEST_BLOCK_SIZE);
 
    if (srb == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // Allocate a transfer buffer for the SCSIOP_FORMAT_UNIT parameter list
    //
    parameterList = ExAllocatePool(NonPagedPoolNx,
                                   sizeof(FORMAT_UNIT_PARAMETER_LIST));
 
    if (parameterList == NULL)
    {
        ExFreePool(srb);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // Initialize the parameter list
    //
    RtlZeroMemory(parameterList, sizeof(FORMAT_UNIT_PARAMETER_LIST));
 
    parameterList->DefectListHeader.SingleTrack = 1;
    parameterList->DefectListHeader.DisableCert = 1;  // TEAC requires this set
    parameterList->DefectListHeader.FormatOptionsValid = 1;
    parameterList->DefectListHeader.DefectListLengthLsb = 8;
 
    parameterList->FormatDescriptor.NumberOfBlocks[0] =
        (UCHAR)((capacity->NumberOfBlocks >> 24) & 0xFF);
 
    parameterList->FormatDescriptor.NumberOfBlocks[1] =
        (UCHAR)((capacity->NumberOfBlocks >> 16) & 0xFF);
 
    parameterList->FormatDescriptor.NumberOfBlocks[2] =
        (UCHAR)((capacity->NumberOfBlocks >> 8) & 0xFF);
 
    parameterList->FormatDescriptor.NumberOfBlocks[3] =
        (UCHAR)(capacity->NumberOfBlocks & 0xFF);
 
    parameterList->FormatDescriptor.BlockLength[0] =
        (UCHAR)((capacity->BlockLength >> 16) & 0xFF);
 
    parameterList->FormatDescriptor.BlockLength[1] =
        (UCHAR)((capacity->BlockLength >> 8) & 0xFF);
 
    parameterList->FormatDescriptor.BlockLength[2] =
        (UCHAR)(capacity->BlockLength & 0xFF);
 
 
    for (cylinder =  formatParameters->StartCylinderNumber;
         cylinder <= formatParameters->EndCylinderNumber;
         cylinder++)
    {
        for (head =  formatParameters->StartHeadNumber;
             head <= formatParameters->EndHeadNumber;
             head++)
        {
            // Initialize the SRB and CDB
            //
            RtlZeroMemory(srb, SCSI_REQUEST_BLOCK_SIZE);
 
            srb->CdbLength = sizeof(CDB12FORMAT);
 
            srb->TimeOutValue = fdoExtension->TimeOutValue;
 
            cdb = (PCDB12FORMAT)srb->Cdb;
 
            cdb->OperationCode = SCSIOP_FORMAT_UNIT;
            cdb->DefectListFormat = 7;
            cdb->FmtData = 1;
            cdb->TrackNumber = (UCHAR)cylinder;
            cdb->ParameterListLengthLsb = sizeof(FORMAT_UNIT_PARAMETER_LIST);
 
            parameterList->DefectListHeader.Side = (UCHAR)head;
 
            //
            // Send down the SCSIOP_FORMAT_UNIT request
            //
            status = ClassSendSrbSynchronous(DeviceObject,
                                             srb,
                                             parameterList,
                                             sizeof(FORMAT_UNIT_PARAMETER_LIST),
                                             TRUE);
 
            if (!NT_SUCCESS(status))
            {
                break;
            }
        }
        if (!NT_SUCCESS(status))
        {
            break;
        }
    }
 
    if (NT_SUCCESS(status) && formatParameters->StartCylinderNumber == 0)
    {
        // Update the device geometry
        //
 
        DebugPrint((2,"geometry was: %3d %2d %d %2d %4d  %2d  %08X\n",
                    fdoExtension->DiskGeometry.Cylinders.LowPart,
                    fdoExtension->DiskGeometry.MediaType,
                    fdoExtension->DiskGeometry.TracksPerCylinder,
                    fdoExtension->DiskGeometry.SectorsPerTrack,
                    fdoExtension->DiskGeometry.BytesPerSector,
                    fdoExtension->SectorShift,
                    fdoExtension->CommonExtension.PartitionLength.LowPart));
 
        fdoExtension->DiskGeometry = *geometry;
 
        //
        // Calculate sector to byte shift.
        //
 
        WHICH_BIT(fdoExtension->DiskGeometry.BytesPerSector,
                  fdoExtension->SectorShift);
 
        fdoExtension->CommonExtension.PartitionLength.QuadPart =
            (LONGLONG)capacity->NumberOfBlocks *
            capacity->BlockLength;
 
        DebugPrint((2,"geometry  is: %3d %2d %d %2d %4d  %2d  %08X\n",
                    fdoExtension->DiskGeometry.Cylinders.LowPart,
                    fdoExtension->DiskGeometry.MediaType,
                    fdoExtension->DiskGeometry.TracksPerCylinder,
                    fdoExtension->DiskGeometry.SectorsPerTrack,
                    fdoExtension->DiskGeometry.BytesPerSector,
                    fdoExtension->SectorShift,
                    fdoExtension->CommonExtension.PartitionLength.LowPart));
    }
 
    // Free everything we allocated
    //
    ExFreePool(parameterList);
    ExFreePool(srb);
 
    return status;
}

Referenced by ScsiFlopDeviceControl().

USBFlopGetMediaTypes()

NTSTATUS USBFlopGetMediaTypes	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 2899 of file floppy.c.

{
/*++
 
Routine Description:
 
    This routines determines the current or default geometry of the drive
    for IOCTL_DISK_GET_DRIVE_GEOMETRY, or all currently supported geometries
    of the drive (which is determined by its currently inserted media) for
    IOCTL_DISK_GET_MEDIA_TYPES.
 
    The returned geometries are determined by issuing a Read Format Capacities
    request and then matching the returned {Number of Blocks, Block Length}
    pairs in a table of known floppy geometries.
 
Arguments:
 
    DeviceObject - Supplies the device object.
 
    Irp - A IOCTL_DISK_GET_DRIVE_GEOMETRY or a IOCTL_DISK_GET_MEDIA_TYPES Irp.
          If NULL, the device geometry is updated with the current device
          geometry.
 
Return Value:
 
    Status is returned.
 
--*/
    PFUNCTIONAL_DEVICE_EXTENSION    fdoExtension;
    PIO_STACK_LOCATION              irpStack;
    ULONG                           ioControlCode;
    PDISK_GEOMETRY                  outputBuffer;
    PDISK_GEOMETRY                  outputBufferEnd;
    ULONG                           outputBufferLength;
    PSCSI_REQUEST_BLOCK             srb;
    PVOID                           dataBuffer;
    ULONG                           dataTransferLength;
    struct _READ_FORMATTED_CAPACITIES *cdb;
    PFORMATTED_CAPACITY_LIST        capList;
    NTSTATUS                        status;
 
    PAGED_CODE();
 
    fdoExtension = DeviceObject->DeviceExtension;
 
    if (Irp != NULL) {
 
        // Get the Irp parameters
        //
        irpStack = IoGetCurrentIrpStackLocation(Irp);
 
        ioControlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;
 
        Irp->IoStatus.Information = 0;
 
        outputBuffer = (PDISK_GEOMETRY) Irp->AssociatedIrp.SystemBuffer;
 
        outputBufferLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
        if (outputBufferLength < sizeof(DISK_GEOMETRY))
        {
            return STATUS_BUFFER_TOO_SMALL;
        }
 
        // Pointer arithmetic to allow multiple DISK_GEOMETRY's to be returned.
        // Rounds BufferEnd down to integral multiple of DISK_GEOMETRY structs.
        //
        outputBufferEnd = outputBuffer +
                          outputBufferLength / sizeof(DISK_GEOMETRY);
 
    } else {
 
        // No Irp to return the result in, just update the current geometry
        // in the device extension.
        //
        ioControlCode = IOCTL_DISK_GET_DRIVE_GEOMETRY;
 
        outputBuffer        = NULL;
 
        outputBufferEnd     = NULL;
 
        outputBufferLength  = 0;
    }
 
    if (ioControlCode == IOCTL_DISK_GET_DRIVE_GEOMETRY) {
 
        fdoExtension->DiskGeometry.MediaType = Unknown;
 
        status = ClassReadDriveCapacity(DeviceObject);
 
        if (!NT_SUCCESS(status))
        {
            // If the media is not recongized, we want to return the default
            // geometry so that the media can be formatted.  Unrecognized media
            // causes SCSI_SENSE_MEDIUM_ERROR, which gets reported as
            // STATUS_DEVICE_DATA_ERROR.  Ignore these errors, but return other
            // errors, such as STATUS_NO_MEDIA_IN_DEVICE.
            //
            if (status != STATUS_UNRECOGNIZED_MEDIA)
            {
                DebugPrint((2,"IOCTL_DISK_GET_DRIVE_GEOMETRY returns %08X\n", status));
 
                return status;
            }
        }
    }
 
    // Allocate an SRB for the SCSIOP_READ_FORMATTED_CAPACITY request
    //
    srb = ExAllocatePool(NonPagedPoolNx, SCSI_REQUEST_BLOCK_SIZE);
 
    if (srb == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // Allocate a transfer buffer for the SCSIOP_READ_FORMATTED_CAPACITY request
    // The length of the returned descriptor array is limited to a byte field
    // in the capacity list header.
    //
    dataTransferLength = sizeof(FORMATTED_CAPACITY_LIST) +
                         31 * sizeof(FORMATTED_CAPACITY_DESCRIPTOR);
 
    ASSERT(dataTransferLength < 0x100);
 
    dataBuffer = ExAllocatePool(NonPagedPoolNx, dataTransferLength);
 
    if (dataBuffer == NULL)
    {
        ExFreePool(srb);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // Initialize the SRB and CDB
    //
    RtlZeroMemory(srb, SCSI_REQUEST_BLOCK_SIZE);
 
    RtlZeroMemory(dataBuffer, dataTransferLength);
 
    srb->CdbLength = sizeof(struct _READ_FORMATTED_CAPACITIES);
 
    srb->TimeOutValue = fdoExtension->TimeOutValue;
 
    cdb = (struct _READ_FORMATTED_CAPACITIES *)srb->Cdb;
 
    cdb->OperationCode = SCSIOP_READ_FORMATTED_CAPACITY;
    cdb->AllocationLength[1] = (UCHAR)dataTransferLength;
 
    //
    // Send down the SCSIOP_READ_FORMATTED_CAPACITY request
    //
    status = ClassSendSrbSynchronous(DeviceObject,
                                     srb,
                                     dataBuffer,
                                     dataTransferLength,
                                     FALSE);
 
    capList = (PFORMATTED_CAPACITY_LIST)dataBuffer;
 
    // If we don't get as much data as requested, it is not an error.
    //
    if (SRB_STATUS(srb->SrbStatus) == SRB_STATUS_DATA_OVERRUN)
    {
        status = STATUS_SUCCESS;
    }
 
    if (NT_SUCCESS(status) &&
        srb->DataTransferLength >= sizeof(FORMATTED_CAPACITY_LIST) &&
        capList->CapacityListLength &&
        capList->CapacityListLength % sizeof(FORMATTED_CAPACITY_DESCRIPTOR) == 0)
    {
        ULONG   NumberOfBlocks;
        ULONG   BlockLength;
        ULONG   count;
        ULONG   i, j;
        LONG    currentGeometry;
        BOOLEAN capacityMatches[FLOPPY_CAPACITIES];
 
        // Subtract the size of the Capacity List Header to get
        // just the size of the Capacity List Descriptor array.
        //
        srb->DataTransferLength -= sizeof(FORMATTED_CAPACITY_LIST);
 
        // Only look at the Capacity List Descriptors that were actually
        // returned.
        //
        if (srb->DataTransferLength < capList->CapacityListLength)
        {
            count = srb->DataTransferLength /
                    sizeof(FORMATTED_CAPACITY_DESCRIPTOR);
        }
        else
        {
            count = capList->CapacityListLength /
                    sizeof(FORMATTED_CAPACITY_DESCRIPTOR);
        }
 
        // Updated only if a match is found for the first Capacity List
        // Descriptor returned by the device.
        //
        currentGeometry = -1;
 
        // Initialize the array of capacities that hit a match.
        //
        RtlZeroMemory(capacityMatches, sizeof(capacityMatches));
 
        // Iterate over each Capacity List Descriptor returned from the device
        // and record matching capacities in the capacity match array.
        //
        for (i = 0; i < count; i++)
        {
            NumberOfBlocks = (capList->Descriptors[i].NumberOfBlocks[0] << 24) +
                             (capList->Descriptors[i].NumberOfBlocks[1] << 16) +
                             (capList->Descriptors[i].NumberOfBlocks[2] <<  8) +
                             (capList->Descriptors[i].NumberOfBlocks[3]);
 
            BlockLength = (capList->Descriptors[i].BlockLength[0] << 16) +
                          (capList->Descriptors[i].BlockLength[1] <<  8) +
                          (capList->Descriptors[i].BlockLength[2]);
 
            // Given the {NumberOfBlocks, BlockLength} from this Capacity List
            // Descriptor, find a matching entry in FloppyCapacities[].
            //
            for (j = 0; j < FLOPPY_CAPACITIES; j++)
            {
                if (NumberOfBlocks == FloppyCapacities[j].NumberOfBlocks &&
                    BlockLength    == FloppyCapacities[j].BlockLength)
                {
                    // A matching capacity was found, record it.
                    //
                    capacityMatches[j] = TRUE;
 
                    // A match was found for the first Capacity List
                    // Descriptor returned by the device.
                    //
                    if (i == 0)
                    {
                        currentGeometry = j;
                    }
                } else if ((capList->Descriptors[i].Valid) &&
                           (BlockLength == FloppyCapacities[j].BlockLength)) {
 
                    ULONG inx;
                    ULONG mediaInx;
 
                    //
                    // Check if this is 32MB media type. 32MB media
                    // reports variable NumberOfBlocks. So we cannot
                    // use that to determine the drive type
                    //
                    inx = DetermineDriveType(DeviceObject);
                    if (inx != DRIVE_TYPE_NONE) {
                        mediaInx = DriveMediaLimits[inx].HighestDriveMediaType;
                        if ((DriveMediaConstants[mediaInx].MediaType)
                             == F3_32M_512) {
                            capacityMatches[j] = TRUE;
 
                            if (i == 0) {
                                currentGeometry = j;
                            }
                        }
                    }
                }
            }
        }
 
        // Default status is STATUS_UNRECOGNIZED_MEDIA, unless we return
        // either STATUS_SUCCESS or STATUS_BUFFER_OVERFLOW.
        //
        status = STATUS_UNRECOGNIZED_MEDIA;
 
        if (ioControlCode == IOCTL_DISK_GET_DRIVE_GEOMETRY) {
 
            if (currentGeometry != -1)
            {
                // Update the current device geometry
                //
                fdoExtension->DiskGeometry = FloppyGeometries[currentGeometry];
 
                //
                // Calculate sector to byte shift.
                //
 
                WHICH_BIT(fdoExtension->DiskGeometry.BytesPerSector,
                          fdoExtension->SectorShift);
 
                fdoExtension->CommonExtension.PartitionLength.QuadPart =
                    (LONGLONG)FloppyCapacities[currentGeometry].NumberOfBlocks *
                    FloppyCapacities[currentGeometry].BlockLength;
 
                DebugPrint((2,"geometry  is: %3d %2d %d %2d %4d  %2d  %08X\n",
                            fdoExtension->DiskGeometry.Cylinders.LowPart,
                            fdoExtension->DiskGeometry.MediaType,
                            fdoExtension->DiskGeometry.TracksPerCylinder,
                            fdoExtension->DiskGeometry.SectorsPerTrack,
                            fdoExtension->DiskGeometry.BytesPerSector,
                            fdoExtension->SectorShift,
                            fdoExtension->CommonExtension.PartitionLength.LowPart));
 
                // Return the current device geometry
                //
                if (Irp != NULL)
                {
                    *outputBuffer = FloppyGeometries[currentGeometry];
 
                    Irp->IoStatus.Information = sizeof(DISK_GEOMETRY);
                }
 
                status = STATUS_SUCCESS;
            }
 
        } else {
 
            // Iterate over the capacities and return the geometry
            // corresponding to each matching Capacity List Descriptor
            // returned from the device.
            //
            // The resulting list should be in sorted ascending order,
            // assuming that the FloppyGeometries[] array is in sorted
            // ascending order.
            //
            for (i = 0; i < FLOPPY_CAPACITIES; i++)
            {
                if (capacityMatches[i] && FloppyCapacities[i].CanFormat)
                {
                    if (outputBuffer < outputBufferEnd)
                    {
                        *outputBuffer++ = FloppyGeometries[i];
 
                        Irp->IoStatus.Information += sizeof(DISK_GEOMETRY);
 
                        DebugPrint((2,"geometry    : %3d %2d %d %2d %4d\n",
                                    FloppyGeometries[i].Cylinders.LowPart,
                                    FloppyGeometries[i].MediaType,
                                    FloppyGeometries[i].TracksPerCylinder,
                                    FloppyGeometries[i].SectorsPerTrack,
                                    FloppyGeometries[i].BytesPerSector));
 
                        status = STATUS_SUCCESS;
                    }
                    else
                    {
                        // We ran out of output buffer room before we ran out
                        // geometries to return.
                        //
                        status = STATUS_BUFFER_OVERFLOW;
                    }
                }
            }
        }
    }
    else if (NT_SUCCESS(status))
    {
        // The SCSIOP_READ_FORMATTED_CAPACITY request was successful, but
        // returned data does not appear valid.
        //
        status = STATUS_UNSUCCESSFUL;
    }
 
    ExFreePool(dataBuffer);
    ExFreePool(srb);
 
    return status;
}

Referenced by ScsiFlopDeviceControl().

Variable Documentation

DriveMediaConstants

DRIVE_MEDIA_CONSTANTS DriveMediaConstants[]

Definition at line 179 of file floppy.c.

Referenced by DetermineDriveType(), DetermineMediaType(), FlCheckFormatParameters(), FlopticalFormatMedia(), FormatMedia(), ScsiFlopDeviceControl(), and USBFlopGetMediaTypes().

DriveMediaLimits

DRIVE_MEDIA_LIMITS DriveMediaLimits[NUMBER_OF_DRIVE_TYPES]

Initial value:

= {
 
    { Drive720Media720, Drive720Media720 }, 
    { Drive144Media144,  Drive144Media720}, 
    { Drive288Media288,  Drive288Media720}, 
    { Drive2080Media2080, Drive2080Media720 },
    { Drive32MMedia32M, Drive32MMedia32M }, 
    { Drive120MMedia120M, Drive120MMedia720 }, 
    { Drive240MMedia240M, Drive240MMedia144M } 
}

Definition at line 142 of file floppy.c.

Referenced by DetermineDriveType(), FlCheckFormatParameters(), ScsiFlopDeviceControl(), and USBFlopGetMediaTypes().

DriverEntry

DRIVER_INITIALIZE DriverEntry

Definition at line 347 of file floppy.c.

FloppyCapacities

FORMATTED_CAPACITY FloppyCapacities[]

Initial value:

=
{
    
    {0x000500, 0x0200,  TRUE}, 
    {0x0005A0, 0x0200,  TRUE}, 
    {0x000960, 0x0200,  TRUE}, 
    {0x0004D0, 0x0400,  TRUE}, 
    {0x000B40, 0x0200,  TRUE}, 
    {0x000D20, 0x0200, FALSE}, 
    {0x010000, 0x0200,  TRUE},  
    {0x03C300, 0x0200,  TRUE}, 
    {0x0600A4, 0x0200,  TRUE}, 
    {0x072A00, 0x0200,  TRUE}  
}

Definition at line 255 of file floppy.c.

Referenced by USBFlopFormatTracks(), and USBFlopGetMediaTypes().

FloppyGeometries

DISK_GEOMETRY FloppyGeometries[]

Initial value:

=
{
    
 
    {{80,0},    F3_640_512,     2,      8,      512},
    {{80,0},    F3_720_512,     2,      9,      512},
    {{80,0},    F3_1Pt2_512,    2,      15,     512},
    {{77,0},    F3_1Pt23_1024,  2,      8,      1024},
    {{80,0},    F3_1Pt44_512,   2,      18,     512},
    {{80,0},    F3_1Pt44_512,   2,      21,     512},   
    {{1024,0},  F3_32M_512,     2,      32,     512},
    {{963,0},   F3_120M_512,    8,      32,     512},
    {{890,0},   F3_200Mb_512,   13,     34,     512},
    {{262,0},   F3_240M_512,    32,     56,     512}
 
 
 
 
 
 
 
 
 
 
 
 
}

Definition at line 270 of file floppy.c.

Referenced by USBFlopFormatTracks(), and USBFlopGetMediaTypes().

ScsiFlopAddDevice

DRIVER_ADD_DEVICE ScsiFlopAddDevice

Definition at line 351 of file floppy.c.

Referenced by DriverEntry().

ScsiFlopUnload

DRIVER_UNLOAD ScsiFlopUnload

Definition at line 349 of file floppy.c.

Referenced by DriverEntry().