/*++ Copyright (C) Microsoft Corporation, 1991 - 1999 Module Name: floppy.c Abstract: SCSI floppy class driver Author: Jeff Havens (jhavens) Environment: kernel mode only Notes: Revision History: 02/28/96 georgioc Merged this code with code developed by compaq in parallel with microsoft, for 120MB floppy support. 01/17/96 georgioc Made code PNP aware (uses the new \storage\classpnp/scsiport) --*/ #if !defined(__REACTOS__) || defined(_MSC_VER) #pragma warning(disable:4214) // nonstandard extension used : bit field types other than int #pragma warning(disable:4201) // nonstandard extension used : nameless struct/union #endif #include #include #ifndef __REACTOS__ #include #endif #include #include #include #include #include #include #ifdef __REACTOS__ // Downgrade unsupported NT6.2+ features. #define NonPagedPoolNx NonPagedPool #define NonPagedPoolNxCacheAligned NonPagedPoolCacheAligned #endif #define MODE_DATA_SIZE 192 #define SCSI_FLOPPY_TIMEOUT 20 #define SFLOPPY_SRB_LIST_SIZE 4 // // Define all possible drive/media combinations, given drives listed above // and media types in ntdddisk.h. // // These values are used to index the DriveMediaConstants table. // #define NUMBER_OF_DRIVE_TYPES 7 #define DRIVE_TYPE_120M 4 //120MB Floptical #define DRIVE_TYPE_NONE NUMBER_OF_DRIVE_TYPES // // This array describes all media types we support. // It should be arranged in the increasing order of density // // For a given drive, we list all the mediatypes that will // work with that drive. For instance, a 120MB drive will // take 720KB media, 1.44MB media, and 120MB media. // // Note that, DriveMediaConstants given below is grouped // as drive and media combination // typedef enum _DRIVE_MEDIA_TYPE { 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; // // When we want to determine the media type in a drive, we will first // guess that the media with highest possible density is in the drive, // and keep trying lower densities until we can successfully read from // the drive. // // These values are used to select a DRIVE_MEDIA_TYPE value. // // The following table defines ranges that apply to the DRIVE_MEDIA_TYPE // enumerated values when trying media types for a particular drive type. // Note that for this to work, the DRIVE_MEDIA_TYPE values must be sorted // by ascending densities within drive types. Also, for maximum track // size to be determined properly, the drive types must be in ascending // order. // typedef struct _DRIVE_MEDIA_LIMITS { DRIVE_MEDIA_TYPE HighestDriveMediaType; DRIVE_MEDIA_TYPE LowestDriveMediaType; } DRIVE_MEDIA_LIMITS, *PDRIVE_MEDIA_LIMITS; #if 0 DRIVE_MEDIA_LIMITS DriveMediaLimits[NUMBER_OF_DRIVE_TYPES] = { { Drive360Media360, Drive360Media160 }, // DRIVE_TYPE_0360 { Drive120Media120, Drive120Media160 }, // DRIVE_TYPE_1200 { Drive720Media720, Drive720Media720 }, // DRIVE_TYPE_0720 { Drive144Media144, Drive144Media720 }, // DRIVE_TYPE_1440 { Drive288Media288, Drive288Media720 }, // DRIVE_TYPE_2880 { Drive2080Media2080, Drive2080Media720 } }; #else DRIVE_MEDIA_LIMITS DriveMediaLimits[NUMBER_OF_DRIVE_TYPES] = { { Drive720Media720, Drive720Media720 }, // DRIVE_TYPE_0720 { Drive144Media144, Drive144Media720}, // DRIVE_TYPE_1440 { Drive288Media288, Drive288Media720}, // DRIVE_TYPE_2880 { Drive2080Media2080, Drive2080Media720 }, { Drive32MMedia32M, Drive32MMedia32M }, // DRIVE_TYPE_32M { Drive120MMedia120M, Drive120MMedia720 }, // DRIVE_TYPE_120M { Drive240MMedia240M, Drive240MMedia144M } // DRIVE_TYPE_240M }; #endif // // For each drive/media combination, define important constants. // typedef struct _DRIVE_MEDIA_CONSTANTS { MEDIA_TYPE MediaType; USHORT BytesPerSector; UCHAR SectorsPerTrack; USHORT MaximumTrack; UCHAR NumberOfHeads; } DRIVE_MEDIA_CONSTANTS, *PDRIVE_MEDIA_CONSTANTS; // // Magic value to add to the SectorLengthCode to use it as a shift value // to determine the sector size. // #define SECTORLENGTHCODE_TO_BYTESHIFT 7 // // The following values were gleaned from many different sources, which // often disagreed with each other. Where numbers were in conflict, I // chose the more conservative or most-often-selected value. // DRIVE_MEDIA_CONSTANTS DriveMediaConstants[] = { { F5_160_512, 0x200, 0x08, 0x27, 0x1 }, { F5_180_512, 0x200, 0x09, 0x27, 0x1 }, { F5_320_1024, 0x400, 0x04, 0x27, 0x2 }, { F5_320_512, 0x200, 0x08, 0x27, 0x2 }, { F5_360_512, 0x200, 0x09, 0x27, 0x2 }, { F3_720_512, 0x200, 0x09, 0x4f, 0x2 }, { F5_160_512, 0x200, 0x08, 0x27, 0x1 }, { F5_180_512, 0x200, 0x09, 0x27, 0x1 }, { F5_320_1024, 0x400, 0x04, 0x27, 0x2 }, { F5_320_512, 0x200, 0x08, 0x27, 0x2 }, { F5_360_512, 0x200, 0x09, 0x27, 0x2 }, { F5_1Pt2_512, 0x200, 0x0f, 0x4f, 0x2 }, { F3_720_512, 0x200, 0x09, 0x4f, 0x2 }, { F3_1Pt44_512, 0x200, 0x12, 0x4f, 0x2 }, { F3_720_512, 0x200, 0x09, 0x4f, 0x2 }, { F3_1Pt44_512, 0x200, 0x12, 0x4f, 0x2 }, { F3_2Pt88_512, 0x200, 0x24, 0x4f, 0x2 }, { F3_720_512, 0x200, 0x09, 0x4f, 0x2 }, { F3_1Pt44_512, 0x200, 0x12, 0x4f, 0x2 }, { F3_20Pt8_512, 0x200, 0x1b, 0xfa, 0x6 }, { F3_32M_512, 0x200, 0x20, 0x3ff,0x2}, { F3_720_512, 0x200, 0x09, 0x4f, 0x2 }, { F3_1Pt44_512, 0x200, 0x12, 0x4f, 0x2 }, { F3_120M_512, 0x200, 0x20, 0x3c2,0x8 }, { F3_1Pt44_512, 0x200, 0x12, 0x4f, 0x2 }, { F3_120M_512, 0x200, 0x20, 0x3c2,0x8 }, { F3_240M_512, 0x200, 0x38, 0x105,0x20} }; #define NUMBER_OF_DRIVE_MEDIA_COMBINATIONS sizeof(DriveMediaConstants)/sizeof(DRIVE_MEDIA_CONSTANTS) // // floppy device data // typedef struct _DISK_DATA { ULONG DriveType; BOOLEAN IsDMF; // BOOLEAN EnableDMF; UNICODE_STRING FloppyInterfaceString; } DISK_DATA, *PDISK_DATA; // // The FloppyCapacities and FloppyGeometries arrays are used by the // USBFlopGetMediaTypes() and USBFlopFormatTracks() routines. // The FloppyCapacities and FloppyGeometries arrays must be kept in 1:1 sync, // i.e. each FloppyGeometries[i] must correspond to each FloppyCapacities[i]. // Also, the arrays must be kept in sorted ascending order so that they // are returned in sorted ascending order by IOCTL_DISK_GET_MEDIA_TYPES. // typedef struct _FORMATTED_CAPACITY { ULONG NumberOfBlocks; ULONG BlockLength; BOOLEAN CanFormat; // return for IOCTL_DISK_GET_MEDIA_TYPES ? } FORMATTED_CAPACITY, *PFORMATTED_CAPACITY; FORMATTED_CAPACITY FloppyCapacities[] = { // Blocks BlockLen CanFormat H T B/S S/T {0x000500, 0x0200, TRUE}, // 2 80 512 8 640 KB F5_640_512 {0x0005A0, 0x0200, TRUE}, // 2 80 512 9 720 KB F3_720_512 {0x000960, 0x0200, TRUE}, // 2 80 512 15 1.20 MB F3_1Pt2_512 (Toshiba) {0x0004D0, 0x0400, TRUE}, // 2 77 1024 8 1.23 MB F3_1Pt23_1024 (NEC) {0x000B40, 0x0200, TRUE}, // 2 80 512 18 1.44 MB F3_1Pt44_512 {0x000D20, 0x0200, FALSE}, // 2 80 512 21 1.70 MB DMF {0x010000, 0x0200, TRUE}, // 2 1024 512 32 32 MB F3_32M_512 {0x03C300, 0x0200, TRUE}, // 8 963 512 32 120 MB F3_120M_512 {0x0600A4, 0x0200, TRUE}, // 13 890 512 34 200 MB F3_200Mb_512 (HiFD) {0x072A00, 0x0200, TRUE} // 32 262 512 56 240 MB F3_240M_512 }; DISK_GEOMETRY FloppyGeometries[] = { // Cyl MediaType Trk/Cyl Sec/Trk Bytes/Sec #ifndef __REACTOS__ {{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}, // DMF -> F3_1Pt44_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} #else {{{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}, // DMF -> F3_1Pt44_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} #endif }; #define FLOPPY_CAPACITIES (sizeof(FloppyCapacities)/sizeof(FloppyCapacities[0])) C_ASSERT((sizeof(FloppyGeometries)/sizeof(FloppyGeometries[0])) == FLOPPY_CAPACITIES); // // The following structures are used by USBFlopFormatTracks() // #pragma pack (push, 1) typedef struct _CDB12FORMAT { UCHAR OperationCode; UCHAR DefectListFormat : 3; UCHAR CmpList : 1; UCHAR FmtData : 1; UCHAR LogicalUnitNumber : 3; UCHAR TrackNumber; UCHAR InterleaveMsb; UCHAR InterleaveLsb; UCHAR Reserved1[2]; UCHAR ParameterListLengthMsb; UCHAR ParameterListLengthLsb; UCHAR Reserved2[3]; } CDB12FORMAT, *PCDB12FORMAT; typedef struct _DEFECT_LIST_HEADER { UCHAR Reserved1; UCHAR Side : 1; UCHAR Immediate : 1; UCHAR Reserved2 : 2; UCHAR SingleTrack : 1; UCHAR DisableCert : 1; UCHAR Reserved3 : 1; UCHAR FormatOptionsValid : 1; UCHAR DefectListLengthMsb; UCHAR DefectListLengthLsb; } DEFECT_LIST_HEADER, *PDEFECT_LIST_HEADER; typedef struct _FORMAT_UNIT_PARAMETER_LIST { DEFECT_LIST_HEADER DefectListHeader; FORMATTED_CAPACITY_DESCRIPTOR FormatDescriptor; } FORMAT_UNIT_PARAMETER_LIST, *PFORMAT_UNIT_PARAMETER_LIST; #pragma pack (pop) DRIVER_INITIALIZE DriverEntry; DRIVER_UNLOAD ScsiFlopUnload; DRIVER_ADD_DEVICE ScsiFlopAddDevice; NTSTATUS #ifdef __REACTOS__ NTAPI #endif ScsiFlopInitDevice( IN PDEVICE_OBJECT Fdo ); NTSTATUS #ifdef __REACTOS__ NTAPI #endif ScsiFlopStartDevice( IN PDEVICE_OBJECT Fdo ); NTSTATUS #ifdef __REACTOS__ NTAPI #endif ScsiFlopRemoveDevice( IN PDEVICE_OBJECT Fdo, IN UCHAR Type ); NTSTATUS #ifdef __REACTOS__ NTAPI #endif 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 #ifdef __REACTOS__ NTAPI #endif ScsiFlopReadWriteVerification( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ); NTSTATUS #ifdef __REACTOS__ NTAPI #endif 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 #ifdef __REACTOS__ NTAPI #endif 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 ); #ifdef ALLOC_PRAGMA #pragma alloc_text(INIT, DriverEntry) #pragma alloc_text(PAGE, ScsiFlopUnload) #pragma alloc_text(PAGE, ScsiFlopAddDevice) #pragma alloc_text(PAGE, CreateFlopDeviceObject) #pragma alloc_text(PAGE, ScsiFlopStartDevice) #pragma alloc_text(PAGE, ScsiFlopRemoveDevice) #pragma alloc_text(PAGE, IsFloppyDevice) #pragma alloc_text(PAGE, DetermineMediaType) #pragma alloc_text(PAGE, DetermineDriveType) #pragma alloc_text(PAGE, FlCheckFormatParameters) #pragma alloc_text(PAGE, FormatMedia) #pragma alloc_text(PAGE, FlopticalFormatMedia) #pragma alloc_text(PAGE, USBFlopGetMediaTypes) #pragma alloc_text(PAGE, USBFlopFormatTracks) #endif NTSTATUS #ifdef __REACTOS__ NTAPI #endif DriverEntry( IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath ) /*++ Routine Description: This is the system initialization routine for installable drivers. It calls the SCSI class driver initialization routine. Arguments: DriverObject - Pointer to driver object created by system. Return Value: NTSTATUS --*/ { 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() VOID #ifdef __REACTOS__ NTAPI #endif ScsiFlopUnload( IN PDRIVER_OBJECT DriverObject ) { PAGED_CODE(); UNREFERENCED_PARAMETER(DriverObject); return; } // // AddDevice operation is performed in CreateFlopDeviceObject function which // is called by ScsiFlopAddDevice (The AddDevice routine for sfloppy.sys). // DO_DEVICE_INITIALIZING flag is cleard upon successfully processing AddDevice // operation in CreateFlopDeviceObject. But PREFAST is currently unable to // detect that DO_DEVICE_INITIALIZING is indeed cleard in CreateFlopDeviceObject // and it raises Warning 28152 (The return from an AddDevice-like function // unexpectedly did not clear DO_DEVICE_INITIALIZING). Suppress that warning // using #pragma. // #if !defined(__REACTOS__) || defined(_MSC_VER) #pragma warning(push) #pragma warning(disable:28152) #endif NTSTATUS #ifdef __REACTOS__ NTAPI #endif ScsiFlopAddDevice ( IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT Pdo ) /*++ Routine Description: This routine creates and initializes a new FDO for the corresponding PDO. It may perform property queries on the FDO but cannot do any media access operations. Arguments: DriverObject - Scsiscan class driver object. Pdo - the physical device object we are being added to Return Value: status --*/ { 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; } NTSTATUS CreateFlopDeviceObject( IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT Pdo, IN ULONG DeviceCount ) /*++ Routine Description: This routine creates an object for the device and then calls the SCSI port driver for media capacity and sector size. Arguments: DriverObject - Pointer to driver object created by system. PortDeviceObject - to connect to SCSI port driver. DeviceCount - Number of previously installed Floppys. AdapterDescriptor - Pointer to structure returned by SCSI port driver describing adapter capabilites (and limitations). DeviceDescriptor - Pointer to configuration information for this device. Return Value: --*/ { 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() #if !defined(__REACTOS__) || defined(_MSC_VER) #pragma warning(pop) #endif NTSTATUS #ifdef __REACTOS__ NTAPI #endif ScsiFlopInitDevice( IN PDEVICE_OBJECT Fdo ) { 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); } #if !defined(__REACTOS__) || defined(_MSC_VER) #pragma warning(suppress:6262) // This function uses 1096 bytes of stack which exceed default value of 1024 bytes used by Code Analysis for flagging as warning #endif #ifdef __REACTOS__ NTSTATUS NTAPI ScsiFlopStartDevice( #else NTSTATUS ScsiFlopStartDevice( #endif IN PDEVICE_OBJECT Fdo ) { 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; } NTSTATUS #ifdef __REACTOS__ NTAPI #endif ScsiFlopReadWriteVerification( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) /*++ Routine Description: Arguments: Return Value: NT Status --*/ { 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; } NTSTATUS #ifdef __REACTOS__ NTAPI #endif ScsiFlopDeviceControl( PDEVICE_OBJECT DeviceObject, PIRP Irp ) /*++ Routine Description: Arguments: Return Value: Status is returned. --*/ { 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, ¤tIrql); 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)§orOffset)->Byte3; cdb->CDB10.LogicalBlockByte1 = ((PFOUR_BYTE)§orOffset)->Byte2; cdb->CDB10.LogicalBlockByte2 = ((PFOUR_BYTE)§orOffset)->Byte1; cdb->CDB10.LogicalBlockByte3 = ((PFOUR_BYTE)§orOffset)->Byte0; cdb->CDB10.TransferBlocksMsb = ((PFOUR_BYTE)§orCount)->Byte1; cdb->CDB10.TransferBlocksLsb = ((PFOUR_BYTE)§orCount)->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 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, ¤tIrql); ClassReleaseRemoveLock(DeviceObject, Irp); ClassCompleteRequest(DeviceObject, Irp, 0); KeLowerIrql(currentIrql); ExFreePool(srb); return status; } // end ScsiFlopDeviceControl() #if 0 BOOLEAN IsFloppyDevice( PDEVICE_OBJECT DeviceObject ) /*++ Routine Description: The routine performs the necessary funcitons to deterime if the device is really a floppy rather than a harddisk. This is done by a mode sense command. First a check is made to see if the medimum type is set. Second a check is made for the flexible parameters mode page. Arguments: DeviceObject - Supplies the device object to be tested. Return Value: Return TRUE if the indicated device is a floppy. --*/ { PVOID modeData; PUCHAR pageData; ULONG length; modeData = ExAllocatePool(NonPagedPoolNxCacheAligned, MODE_DATA_SIZE); if (modeData == NULL) { return(FALSE); } RtlZeroMemory(modeData, MODE_DATA_SIZE); length = ClassModeSense(DeviceObject, 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, modeData, MODE_DATA_SIZE, MODE_SENSE_RETURN_ALL); if (length < sizeof(MODE_PARAMETER_HEADER)) { ExFreePool(modeData); return(FALSE); } } #if 0 // // Some drives incorrectly report this. In particular the SONY RMO-S350 // when in disk mode. // if (((PMODE_PARAMETER_HEADER) modeData)->MediumType >= MODE_FD_SINGLE_SIDE && ((PMODE_PARAMETER_HEADER) modeData)->MediumType <= MODE_FD_MAXIMUM_TYPE) { DebugPrint((1, "ScsiFlop: MediumType value %2x, This is a floppy.\n", ((PMODE_PARAMETER_HEADER) modeData)->MediumType)); ExFreePool(modeData); return(TRUE); } #endif // // If the length is greater than length indiated by the mode data reset // the data to the mode data. // if (length > (ULONG)((PMODE_PARAMETER_HEADER) modeData)->ModeDataLength + 1) { length = (ULONG)((PMODE_PARAMETER_HEADER) modeData)->ModeDataLength + 1; } // // Look for the flexible disk mode page. // pageData = ClassFindModePage( modeData, length, MODE_PAGE_FLEXIBILE, TRUE); if (pageData != NULL) { DebugPrint((1, "ScsiFlop: Flexible disk page found, This is a floppy.\n")); // // As a special case for the floptical driver do a magic mode sense to // enable the drive. // ClassModeSense(DeviceObject, modeData, 0x2a, 0x2e); ExFreePool(modeData); return(TRUE); } ExFreePool(modeData); return(FALSE); } #endif NTSTATUS DetermineMediaType( PDEVICE_OBJECT DeviceObject ) /*++ Routine Description: This routine determines the floppy media type based on the size of the device. The geometry information is set for the device object. Arguments: DeviceObject - Supplies the device object to be tested. Return Value: None --*/ { 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; } ULONG DetermineDriveType( PDEVICE_OBJECT DeviceObject ) /*++ Routine Description: The routine determines the device type so that the supported medias can be determined. It does a mode sense for the default parameters. This code assumes that the returned values are for the maximum device size. Arguments: DeviceObject - Supplies the device object to be tested. Return Value: None --*/ { 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); } BOOLEAN FlCheckFormatParameters( IN PDEVICE_OBJECT DeviceObject, IN PFORMAT_PARAMETERS FormatParameters ) /*++ Routine Description: This routine checks the supplied format parameters to make sure that they'll work on the drive to be formatted. Arguments: DeviceObject - Pointer to the device object to be formated. FormatParameters - a pointer to the caller's parameters for the FORMAT. Return Value: TRUE if parameters are OK. FALSE if the parameters are bad. --*/ { 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 } NTSTATUS FormatMedia( PDEVICE_OBJECT DeviceObject, MEDIA_TYPE MediaType ) /*++ Routine Description: This routine formats the floppy disk. The entire floppy is formated in one shot. Arguments: DeviceObject - Supplies the device object to be tested. Irp - Supplies a pointer to the requesting Irp. MediaType - Supplies the media type format the device for. Return Value: Returns a status for the operation. --*/ { 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); } VOID #ifdef __REACTOS__ NTAPI #endif ScsiFlopProcessError( PDEVICE_OBJECT DeviceObject, PSCSI_REQUEST_BLOCK Srb, NTSTATUS *Status, BOOLEAN *Retry ) /*++ Routine Description: This routine checks the type of error. If the error indicate the floppy controller needs to be reinitialize a command is made to do it. Arguments: DeviceObject - Supplies a pointer to the device object. Srb - Supplies a pointer to the failing Srb. Status - Status with which the IRP will be completed. Retry - Indication of whether the request will be retried. Return Value: None. --*/ { 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; } NTSTATUS FlopticalFormatMedia( PDEVICE_OBJECT DeviceObject, PFORMAT_PARAMETERS Format ) /*++ Routine Description: This routine is used to do perform a format tracks for the 20.8 MB floppy. Because the device does not support format tracks and the full format takes a long time a write of zeros is done instead. Arguments: DeviceObject - Supplies the device object to be tested. Format - Supplies the format parameters. Return Value: Returns a status for the operation. --*/ { 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); } NTSTATUS #ifdef __REACTOS__ NTAPI #endif ScsiFlopRemoveDevice( IN PDEVICE_OBJECT DeviceObject, IN UCHAR Type ) /*++ Routine Description: This routine is responsible for releasing any resources in use by the sfloppy driver. This routine is called when all outstanding requests have been completed and the driver has disappeared - no requests may be issued to the lower drivers. Arguments: DeviceObject - the device object being removed Type - the type of remove operation (QUERY, REMOVE or CANCEL) Return Value: for a query - success if the device can be removed or a failure code indiciating why not. for a remove or cancel - STATUS_SUCCESS --*/ { 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; } NTSTATUS #ifdef __REACTOS__ NTAPI #endif ScsiFlopStopDevice( IN PDEVICE_OBJECT DeviceObject, IN UCHAR Type ) { UNREFERENCED_PARAMETER(DeviceObject); UNREFERENCED_PARAMETER(Type); return STATUS_SUCCESS; } NTSTATUS USBFlopGetMediaTypes( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) { /*++ 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; } NTSTATUS USBFlopFormatTracks( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) { /*++ 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; iMediaType) { 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; }