ReactOS  0.4.14-dev-49-gfb4591c
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_LIMITSPDRIVE_MEDIA_LIMITS
 
typedef struct _DRIVE_MEDIA_CONSTANTS DRIVE_MEDIA_CONSTANTS
 
typedef struct _DRIVE_MEDIA_CONSTANTSPDRIVE_MEDIA_CONSTANTS
 
typedef struct _DISK_DATA DISK_DATA
 
typedef struct _DISK_DATAPDISK_DATA
 
typedef struct _FORMATTED_CAPACITY FORMATTED_CAPACITY
 
typedef struct _FORMATTED_CAPACITYPFORMATTED_CAPACITY
 
typedef struct _CDB12FORMAT CDB12FORMAT
 
typedef struct _CDB12FORMATPCDB12FORMAT
 
typedef struct _DEFECT_LIST_HEADER DEFECT_LIST_HEADER
 
typedef struct _DEFECT_LIST_HEADERPDEFECT_LIST_HEADER
 
typedef struct _FORMAT_UNIT_PARAMETER_LIST FORMAT_UNIT_PARAMETER_LIST
 
typedef struct _FORMAT_UNIT_PARAMETER_LISTPFORMAT_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 60 of file floppy.c.

◆ DRIVE_TYPE_NONE

#define DRIVE_TYPE_NONE   NUMBER_OF_DRIVE_TYPES

Definition at line 61 of file floppy.c.

◆ FLOPPY_CAPACITIES

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

Definition at line 292 of file floppy.c.

◆ MODE_DATA_SIZE

#define MODE_DATA_SIZE   192

Definition at line 49 of file floppy.c.

◆ NUMBER_OF_DRIVE_MEDIA_COMBINATIONS

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

Definition at line 214 of file floppy.c.

◆ NUMBER_OF_DRIVE_TYPES

#define NUMBER_OF_DRIVE_TYPES   7

Definition at line 59 of file floppy.c.

◆ SCSI_FLOPPY_TIMEOUT

#define SCSI_FLOPPY_TIMEOUT   20

Definition at line 50 of file floppy.c.

◆ SECTORLENGTHCODE_TO_BYTESHIFT

#define SECTORLENGTHCODE_TO_BYTESHIFT   7

Definition at line 165 of file floppy.c.

◆ SFLOPPY_SRB_LIST_SIZE

#define SFLOPPY_SRB_LIST_SIZE   4

Definition at line 51 of file floppy.c.

Typedef Documentation

◆ CDB12FORMAT

◆ DEFECT_LIST_HEADER

◆ DISK_DATA

◆ DRIVE_MEDIA_CONSTANTS

◆ DRIVE_MEDIA_LIMITS

◆ DRIVE_MEDIA_TYPE

◆ FORMAT_UNIT_PARAMETER_LIST

◆ FORMATTED_CAPACITY

◆ PCDB12FORMAT

◆ PDEFECT_LIST_HEADER

◆ PDISK_DATA

◆ PDRIVE_MEDIA_CONSTANTS

◆ PDRIVE_MEDIA_LIMITS

◆ PFORMAT_UNIT_PARAMETER_LIST

◆ PFORMATTED_CAPACITY

Enumeration Type Documentation

◆ _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 74 of file floppy.c.

74  {
75  Drive360Media160, // 5.25" 360k drive; 160k media
76  Drive360Media180, // 5.25" 360k drive; 180k media
77  Drive360Media320, // 5.25" 360k drive; 320k media
78  Drive360Media32X, // 5.25" 360k drive; 320k 1k secs
79  Drive360Media360, // 5.25" 360k drive; 360k media
80  Drive720Media720, // 3.5" 720k drive; 720k media
81  Drive120Media160, // 5.25" 1.2Mb drive; 160k media
82  Drive120Media180, // 5.25" 1.2Mb drive; 180k media
83  Drive120Media320, // 5.25" 1.2Mb drive; 320k media
84  Drive120Media32X, // 5.25" 1.2Mb drive; 320k 1k secs
85  Drive120Media360, // 5.25" 1.2Mb drive; 360k media
86  Drive120Media120, // 5.25" 1.2Mb drive; 1.2Mb media
87  Drive144Media720, // 3.5" 1.44Mb drive; 720k media
88  Drive144Media144, // 3.5" 1.44Mb drive; 1.44Mb media
89  Drive288Media720, // 3.5" 2.88Mb drive; 720k media
90  Drive288Media144, // 3.5" 2.88Mb drive; 1.44Mb media
91  Drive288Media288, // 3.5" 2.88Mb drive; 2.88Mb media
92  Drive2080Media720, // 3.5" 20.8Mb drive; 720k media
93  Drive2080Media144, // 3.5" 20.8Mb drive; 1.44Mb media
94  Drive2080Media2080, // 3.5" 20.8Mb drive; 20.8Mb media
95  Drive32MMedia32M, // 3.5" 32Mb drive; 32MB media
96  Drive120MMedia720, // 3.5" 120Mb drive; 720k media
97  Drive120MMedia144, // 3.5" 120Mb drive; 1.44Mb media
98  Drive120MMedia120M, // 3.5" 120Mb drive; 120Mb media
99  Drive240MMedia144M, // 3.5" 240Mb drive; 1.44Mb media
100  Drive240MMedia120M, // 3.5" 240Mb drive; 120Mb media
101  Drive240MMedia240M // 3.5" 240Mb drive; 240Mb media
enum _DRIVE_MEDIA_TYPE DRIVE_MEDIA_TYPE

Function Documentation

◆ C_ASSERT()

◆ CreateFlopDeviceObject()

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

Definition at line 645 of file floppy.c.

670 {
672  PDEVICE_OBJECT deviceObject = NULL;
673  PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = NULL;
674  PDISK_DATA diskData;
675 
676  PAGED_CODE();
677 
678  DebugPrint((3,"CreateFlopDeviceObject: Enter routine\n"));
679 
680  //
681  // Try to claim the device.
682  //
683 
685 
686  if (!NT_SUCCESS(status)) {
687  return(status);
688  }
689 
690  DeviceCount--;
691 
692  do {
693  UCHAR name[256];
694 
695  //
696  // Create device object for this device.
697  //
698 
699  DeviceCount++;
700 
701  status = RtlStringCbPrintfA((PCCHAR) name,
702  sizeof(name)/sizeof(UCHAR),
703  "\\Device\\Floppy%u",
704  DeviceCount);
705  if (NT_SUCCESS(status)) {
706 
708  (PCCHAR) name,
709  Pdo,
710  TRUE,
711  &deviceObject);
712  }
713  } while ((status == STATUS_OBJECT_NAME_COLLISION) ||
715 
716  if (!NT_SUCCESS(status)) {
717  DebugPrint((1,"CreateFlopDeviceObjects: Can not create device\n"));
718  goto CreateFlopDeviceObjectExit;
719  }
720 
721  //
722  // Indicate that IRPs should include MDLs.
723  //
724 
725  deviceObject->Flags |= DO_DIRECT_IO;
726 
727  fdoExtension = deviceObject->DeviceExtension;
728 
729  //
730  // Back pointer to device object.
731  //
732 
733  fdoExtension->CommonExtension.DeviceObject = deviceObject;
734 
735  //
736  // This is the physical device.
737  //
738 
739  fdoExtension->CommonExtension.PartitionZeroExtension = fdoExtension;
740 
741  //
742  // Reset the drive type.
743  //
744 
745  diskData = (PDISK_DATA) fdoExtension->CommonExtension.DriverData;
746  diskData->DriveType = DRIVE_TYPE_NONE;
747  diskData->IsDMF = FALSE;
748  // diskData->EnableDMF = TRUE;
749 
750  //
751  // Initialize lock count to zero. The lock count is used to
752  // disable the ejection mechanism when media is mounted.
753  //
754 
755  fdoExtension->LockCount = 0;
756 
757  //
758  // Save system floppy number
759  //
760 
761  fdoExtension->DeviceNumber = DeviceCount;
762 
763  //
764  // Set the alignment requirements for the device based on the
765  // host adapter requirements
766  //
767 
768  if (Pdo->AlignmentRequirement > deviceObject->AlignmentRequirement) {
770  }
771 
772  //
773  // Clear the SrbFlags and disable synchronous transfers
774  //
775 
777 
778  //
779  // Finally, attach to the PDO
780  //
781 
782  fdoExtension->LowerPdo = Pdo;
783 
784  fdoExtension->CommonExtension.LowerDeviceObject =
785  IoAttachDeviceToDeviceStack(deviceObject, Pdo);
786 
787  if(fdoExtension->CommonExtension.LowerDeviceObject == NULL) {
788 
790  goto CreateFlopDeviceObjectExit;
791  }
792 
793  deviceObject->StackSize++;
794 
795  //
796  // The device is initialized properly - mark it as such.
797  //
798 
799  deviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
800 
801  return STATUS_SUCCESS;
802 
803 CreateFlopDeviceObjectExit:
804 
805  if (deviceObject != NULL) {
806  IoDeleteDevice(deviceObject);
807  }
808 
809  return status;
810 
811 } // end CreateFlopDeviceObject()
#define DO_DEVICE_INITIALIZING
Definition: env_spec_w32.h:399
#define STATUS_OBJECT_NAME_COLLISION
Definition: udferr_usr.h:150
#define TRUE
Definition: types.h:120
_In_ PDEVICE_OBJECT Pdo
Definition: classpnp.h:301
#define STATUS_OBJECT_NAME_EXISTS
Definition: ntstatus.h:114
LONG NTSTATUS
Definition: precomp.h:26
COMMON_DEVICE_EXTENSION CommonExtension
Definition: classpnp.h:695
#define PAGED_CODE()
Definition: video.h:57
#define DO_DIRECT_IO
Definition: env_spec_w32.h:396
PDEVICE_OBJECT DeviceObject
Definition: kstypes.h:153
ULONG DeviceCount
Definition: mpu401.c:26
PDEVICE_OBJECT NTAPI IoAttachDeviceToDeviceStack(IN PDEVICE_OBJECT SourceDevice, IN PDEVICE_OBJECT TargetDevice)
Definition: device.c:966
PVOID DeviceExtension
Definition: env_spec_w32.h:418
smooth NULL
Definition: ftsmooth.c:416
NTSTATUS NTAPI ClassCreateDeviceObject(IN PDRIVER_OBJECT DriverObject, IN PCCHAR ObjectNameBuffer, IN PDEVICE_OBJECT LowerDevice, IN BOOLEAN IsFdo, IN OUT PDEVICE_OBJECT *DeviceObject)
Definition: class.c:5687
static PDRIVER_OBJECT DriverObject
Definition: template.c:42
BOOLEAN IsDMF
Definition: floppy.c:222
struct _DISK_DATA * PDISK_DATA
NTSTRSAFEVAPI RtlStringCbPrintfA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ _Printf_format_string_ NTSTRSAFE_PCSTR pszFormat,...)
Definition: ntstrsafe.h:1148
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define SRB_FLAGS_DISABLE_SYNCH_TRANSFER
Definition: srb.h:389
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
unsigned char UCHAR
Definition: xmlstorage.h:181
PDEVICE_OBJECT LowerPdo
Definition: classpnp.h:697
ULONG AlignmentRequirement
Definition: env_spec_w32.h:420
ULONG NTAPI DebugPrint(IN PSTRING DebugString, IN ULONG ComponentId, IN ULONG Level)
Definition: debug.c:23
NTSTATUS NTAPI ClassClaimDevice(IN PDEVICE_OBJECT LowerDeviceObject, IN BOOLEAN Release)
Definition: class.c:5985
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1251
#define DRIVE_TYPE_NONE
Definition: floppy.c:61
ULONG DriveType
Definition: floppy.c:221
Definition: name.c:36
return STATUS_SUCCESS
Definition: btrfs.c:2966
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by ScsiFlopAddDevice().

◆ DetermineDriveType()

ULONG DetermineDriveType ( PDEVICE_OBJECT  DeviceObject)

Definition at line 1913 of file floppy.c.

1933 {
1935  PVOID modeData;
1936  PDISK_DATA diskData = (PDISK_DATA) fdoExtension->CommonExtension.DriverData;
1937  PMODE_FLEXIBLE_DISK_PAGE pageData;
1938  ULONG length;
1939  LONG index;
1940  UCHAR numberOfHeads;
1941  UCHAR sectorsPerTrack;
1942  USHORT maximumTrack;
1943  BOOLEAN applyFix = FALSE;
1944 
1945  PAGED_CODE();
1946 
1947  if (diskData->DriveType != DRIVE_TYPE_NONE) {
1948  return(diskData->DriveType);
1949  }
1950 
1951 #ifndef __REACTOS__
1952  modeData = ExAllocatePool(NonPagedPoolNxCacheAligned, MODE_DATA_SIZE);
1953 #else
1955 #endif
1956 
1957  if (modeData == NULL) {
1958  return(DRIVE_TYPE_NONE);
1959  }
1960 
1961  RtlZeroMemory(modeData, MODE_DATA_SIZE);
1962 
1964  modeData,
1967 
1968  if (length < sizeof(MODE_PARAMETER_HEADER)) {
1969 
1970  //
1971  // Retry the request one more time
1972  // in case of a check condition.
1973  //
1975  modeData,
1978 
1979  if (length < sizeof(MODE_PARAMETER_HEADER)) {
1980 
1981  ExFreePool(modeData);
1982  return(DRIVE_TYPE_NONE);
1983  }
1984  }
1985 
1986  //
1987  // Look for the flexible disk mode page.
1988  //
1989 
1990  pageData = ClassFindModePage( modeData,
1991  length,
1993  TRUE);
1994 
1995  //
1996  // Make sure the page is returned and is large enough.
1997  //
1998 
1999  if ((pageData != NULL) &&
2000  (pageData->PageLength + 2 >=
2001  (UCHAR)offsetof(MODE_FLEXIBLE_DISK_PAGE, StartWritePrecom))) {
2002 
2003  //
2004  // Pull out the heads, cylinders, and sectors.
2005  //
2006 
2007  numberOfHeads = pageData->NumberOfHeads;
2008  maximumTrack = pageData->NumberOfCylinders[1];
2009  maximumTrack |= pageData->NumberOfCylinders[0] << 8;
2010  sectorsPerTrack = pageData->SectorsPerTrack;
2011 
2012 
2013  //
2014  // Convert from number of cylinders to maximum track.
2015  //
2016 
2017  maximumTrack--;
2018 
2019  //
2020  // Search for the maximum supported media. Based on the number of heads,
2021  // sectors per track and number of cylinders
2022  //
2024 
2025  //
2026  // Walk the table forward until the drive capacity holds all of the
2027  // data and the bytes per setor are equal
2028  //
2029 
2030  if (DriveMediaConstants[index].NumberOfHeads == numberOfHeads &&
2031  DriveMediaConstants[index].MaximumTrack == maximumTrack &&
2032  DriveMediaConstants[index].SectorsPerTrack ==sectorsPerTrack) {
2033 
2034  ExFreePool(modeData);
2035 
2036  //
2037  // index is now a drive media combination. Compare this to
2038  // the maximum drive media type in the drive media table.
2039  //
2040 
2041  for (length = 0; length < NUMBER_OF_DRIVE_TYPES; length++) {
2042 
2043  if (DriveMediaLimits[length].HighestDriveMediaType == index) {
2044  return(length);
2045  }
2046  }
2047  return(DRIVE_TYPE_NONE);
2048  }
2049  }
2050 
2051  // If the maximum track is greater than 8 bits then divide the
2052  // number of tracks by 3 and multiply the number of heads by 3.
2053  // This is a special case for the 20.8 MB floppy.
2054  //
2055 
2056  if (!applyFix && maximumTrack >= 0x0100) {
2057  maximumTrack++;
2058  maximumTrack /= 3;
2059  maximumTrack--;
2060  numberOfHeads *= 3;
2061  } else {
2062  ExFreePool(modeData);
2063  return(DRIVE_TYPE_NONE);
2064  }
2065 
2066  }
2067 
2068  ExFreePool(modeData);
2069  return(DRIVE_TYPE_NONE);
2070 }
DRIVE_MEDIA_CONSTANTS DriveMediaConstants[]
Definition: floppy.c:173
#define TRUE
Definition: types.h:120
DRIVE_MEDIA_LIMITS DriveMediaLimits[NUMBER_OF_DRIVE_TYPES]
Definition: floppy.c:136
COMMON_DEVICE_EXTENSION CommonExtension
Definition: classpnp.h:695
ULONG NTAPI ClassModeSense(IN PDEVICE_OBJECT Fdo, IN PCHAR ModeSenseBuffer, IN ULONG Length, IN UCHAR PageMode)
Definition: class.c:4122
_In_ ULONG _In_ ULONG _In_ ULONG NumberOfHeads
Definition: iofuncs.h:2066
#define PAGED_CODE()
Definition: video.h:57
_In_ ULONG _In_ ULONG SectorsPerTrack
Definition: iofuncs.h:2066
long LONG
Definition: pedump.c:60
PVOID DeviceExtension
Definition: env_spec_w32.h:418
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
#define offsetof(TYPE, MEMBER)
PVOID NTAPI ClassFindModePage(IN PCHAR ModeSenseBuffer, IN ULONG Length, IN UCHAR PageMode, IN BOOLEAN Use6Byte)
Definition: class.c:4209
GLuint index
Definition: glext.h:6031
struct _DISK_DATA * PDISK_DATA
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
#define MODE_DATA_SIZE
Definition: floppy.c:49
unsigned char UCHAR
Definition: xmlstorage.h:181
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
#define NUMBER_OF_DRIVE_MEDIA_COMBINATIONS
Definition: floppy.c:214
#define NUMBER_OF_DRIVE_TYPES
Definition: floppy.c:59
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
unsigned short USHORT
Definition: pedump.c:61
#define DRIVE_TYPE_NONE
Definition: floppy.c:61
ULONG DriveType
Definition: floppy.c:221
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define MODE_PAGE_FLEXIBILE
Definition: scsi.h:196

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

◆ DetermineMediaType()

NTSTATUS DetermineMediaType ( PDEVICE_OBJECT  DeviceObject)

Definition at line 1745 of file floppy.c.

1764 {
1766  PDISK_GEOMETRY geometry;
1767  LONG index;
1768  NTSTATUS status;
1769 
1770  PAGED_CODE();
1771 
1772  geometry = &(fdoExtension->DiskGeometry);
1773 
1774  //
1775  // Issue ReadCapacity to update device extension
1776  // with information for current media.
1777  //
1778 
1780 
1781  if (!NT_SUCCESS(status)) {
1782 
1783  //
1784  // Set the media type to unknow and zero the geometry information.
1785  //
1786 
1787  geometry->MediaType = Unknown;
1788 
1789  return status;
1790 
1791  }
1792 
1793  //
1794  // Look at the capcity of disk to determine its type.
1795  //
1796 
1797  for (index = NUMBER_OF_DRIVE_MEDIA_COMBINATIONS - 1; index >= 0; index--) {
1798 
1799  //
1800  // Walk the table backward untill the drive capacity holds all of the
1801  // data and the bytes per setor are equal
1802  //
1803 
1805  (DriveMediaConstants[index].MaximumTrack + 1) *
1807  DriveMediaConstants[index].BytesPerSector) <=
1808  fdoExtension->CommonExtension.PartitionLength.LowPart &&
1810  geometry->BytesPerSector) {
1811 
1816  break;
1817  }
1818  }
1819 
1820  if (index == -1) {
1821 
1822  //
1823  // Set the media type to unknow and zero the geometry information.
1824  //
1825 
1826  geometry->MediaType = Unknown;
1827 
1828 
1829  } else {
1830  //
1831  // DMF check breaks the insight SCSI floppy, so its disabled for that case
1832  //
1833  PDISK_DATA diskData = (PDISK_DATA) fdoExtension->CommonExtension.DriverData;
1834 
1835  // if (diskData->EnableDMF == TRUE) {
1836 
1837  //
1838  //check to see if DMF
1839  //
1840 
1841  PSCSI_REQUEST_BLOCK srb;
1842  PVOID readData;
1843 
1844  //
1845  // Allocate a Srb for the read command.
1846  //
1847 
1848 #ifndef __REACTOS__
1849  readData = ExAllocatePool(NonPagedPoolNx, geometry->BytesPerSector);
1850 #else
1851  readData = ExAllocatePool(NonPagedPool, geometry->BytesPerSector);
1852 #endif
1853  if (readData == NULL) {
1854  return STATUS_NO_MEMORY;
1855  }
1856 
1857 #ifndef __REACTOS__
1858  srb = ExAllocatePool(NonPagedPoolNx, SCSI_REQUEST_BLOCK_SIZE);
1859 #else
1861 #endif
1862 
1863  if (srb == NULL) {
1864 
1865  ExFreePool(readData);
1866  return STATUS_NO_MEMORY;
1867  }
1868 
1869  RtlZeroMemory(readData, geometry->BytesPerSector);
1871 
1872  srb->CdbLength = 10;
1873  srb->Cdb[0] = SCSIOP_READ;
1874  srb->Cdb[5] = 0;
1875  srb->Cdb[8] = (UCHAR) 1;
1876 
1877  //
1878  // Set timeout value.
1879  //
1880 
1881  srb->TimeOutValue = fdoExtension->TimeOutValue;
1882 
1883  //
1884  // Send the mode select data.
1885  //
1886 
1888  srb,
1889  readData,
1890  geometry->BytesPerSector,
1891  FALSE
1892  );
1893 
1894  if (NT_SUCCESS(status)) {
1895  char *pchar = (char *)readData;
1896 
1897  pchar += 3; //skip 3 bytes jump code
1898 
1899  // If the MSDMF3. signature is there then mark it as DMF diskette
1900  if (RtlCompareMemory(pchar, "MSDMF3.", 7) == 7) {
1901  diskData->IsDMF = TRUE;
1902  }
1903 
1904  }
1905  ExFreePool(readData);
1906  ExFreePool(srb);
1907  // }// else
1908  }
1909  return status;
1910 }
DRIVE_MEDIA_CONSTANTS DriveMediaConstants[]
Definition: floppy.c:173
#define TRUE
Definition: types.h:120
DISK_GEOMETRY DiskGeometry
Definition: classpnp.h:704
LONG NTSTATUS
Definition: precomp.h:26
COMMON_DEVICE_EXTENSION CommonExtension
Definition: classpnp.h:695
ULONG BytesPerSector
Definition: ntdddisk.h:376
ULONG TracksPerCylinder
Definition: ntdddisk.h:374
_In_ ULONG _In_ ULONG _In_ ULONG NumberOfHeads
Definition: iofuncs.h:2066
#define PAGED_CODE()
Definition: video.h:57
NTSTATUS NTAPI ClassSendSrbSynchronous(PDEVICE_OBJECT Fdo, PSCSI_REQUEST_BLOCK Srb, PVOID BufferAddress, ULONG BufferLength, BOOLEAN WriteToDevice)
Definition: class.c:2648
_In_ ULONG _In_ ULONG SectorsPerTrack
Definition: iofuncs.h:2066
long LONG
Definition: pedump.c:60
#define SCSIOP_READ
Definition: cdrw_hw.h:905
PVOID DeviceExtension
Definition: env_spec_w32.h:418
smooth NULL
Definition: ftsmooth.c:416
BOOLEAN IsDMF
Definition: floppy.c:222
GLuint index
Definition: glext.h:6031
struct _DISK_DATA * PDISK_DATA
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
LARGE_INTEGER Cylinders
Definition: ntdddisk.h:372
ULONG SectorsPerTrack
Definition: ntdddisk.h:375
MEDIA_TYPE MediaType
Definition: ntdddisk.h:373
unsigned char UCHAR
Definition: xmlstorage.h:181
#define index(s, c)
Definition: various.h:29
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
ULONG LowPart
Definition: typedefs.h:104
#define NUMBER_OF_DRIVE_MEDIA_COMBINATIONS
Definition: floppy.c:214
MEDIA_TYPE MediaType
Definition: floppy.c:153
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
#define SCSI_REQUEST_BLOCK_SIZE
Definition: srb.h:274
NTSTATUS NTAPI ClassReadDriveCapacity(IN PDEVICE_OBJECT Fdo)
Definition: class.c:1729
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
static SERVICE_STATUS status
Definition: service.c:31
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define RtlCompareMemory(s1, s2, l)
Definition: env_spec_w32.h:465
Definition: ps.c:97

Referenced by ScsiFlopDeviceControl(), and ScsiFlopStartDevice().

◆ DriverEntry()

NTSTATUS DriverEntry ( IN PDRIVER_OBJECT  DriverObject,
IN PUNICODE_STRING  RegistryPath 
)

Definition at line 495 of file floppy.c.

516 {
518 
519  //
520  // Zero InitData
521  //
522 
524 
525  //
526  // Set sizes
527  //
528 
529  InitializationData.InitializationDataSize = sizeof(CLASS_INIT_DATA);
530  InitializationData.FdoData.DeviceExtensionSize =
531  sizeof(FUNCTIONAL_DEVICE_EXTENSION) + sizeof(DISK_DATA);
532 
533  InitializationData.FdoData.DeviceType = FILE_DEVICE_DISK;
534  InitializationData.FdoData.DeviceCharacteristics = FILE_REMOVABLE_MEDIA | FILE_FLOPPY_DISKETTE;
535 
536  //
537  // Set entry points
538  //
539 
540  InitializationData.FdoData.ClassInitDevice = ScsiFlopInitDevice;
541  InitializationData.FdoData.ClassStartDevice = ScsiFlopStartDevice;
542  InitializationData.FdoData.ClassStopDevice = ScsiFlopStopDevice;
543  InitializationData.FdoData.ClassRemoveDevice = ScsiFlopRemoveDevice;
544 
545  InitializationData.FdoData.ClassReadWriteVerification = ScsiFlopReadWriteVerification;
546  InitializationData.FdoData.ClassDeviceControl = ScsiFlopDeviceControl;
547 
548  InitializationData.FdoData.ClassShutdownFlush = NULL;
549  InitializationData.FdoData.ClassCreateClose = NULL;
550  InitializationData.FdoData.ClassError = ScsiFlopProcessError;
551  InitializationData.ClassStartIo = NULL;
552 
553  InitializationData.ClassAddDevice = ScsiFlopAddDevice;
554  InitializationData.ClassUnload = ScsiFlopUnload;
555  //
556  // Call the class init routine
557  //
558 
560 
561 
562 } // end DriverEntry()
ULONG NTAPI ClassInitialize(IN PVOID Argument1, IN PVOID Argument2, IN PCLASS_INIT_DATA InitializationData)
Definition: class.c:120
#define FILE_DEVICE_DISK
Definition: winioctl.h:112
VOID ScsiFlopProcessError(PDEVICE_OBJECT DeviceObject, PSCSI_REQUEST_BLOCK Srb, NTSTATUS *Status, BOOLEAN *Retry)
Definition: floppy.c:2427
NTSTATUS ScsiFlopStartDevice(IN PDEVICE_OBJECT Fdo)
Definition: floppy.c:943
DRIVER_ADD_DEVICE ScsiFlopAddDevice
Definition: floppy.c:345
NTSTATUS ScsiFlopInitDevice(IN PDEVICE_OBJECT Fdo)
Definition: floppy.c:820
#define FILE_REMOVABLE_MEDIA
Definition: nt_native.h:807
struct _FUNCTIONAL_DEVICE_EXTENSION FUNCTIONAL_DEVICE_EXTENSION
smooth NULL
Definition: ftsmooth.c:416
static PDRIVER_OBJECT DriverObject
Definition: template.c:42
_In_ PVOID _In_ PCLASS_INIT_DATA InitializationData
Definition: classpnp.h:680
NTSTATUS ScsiFlopReadWriteVerification(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: floppy.c:1085
struct _CLASS_INIT_DATA CLASS_INIT_DATA
DRIVER_UNLOAD ScsiFlopUnload
Definition: floppy.c:343
NTSTATUS ScsiFlopDeviceControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS ScsiFlopRemoveDevice(IN PDEVICE_OBJECT Fdo, IN UCHAR Type)
Definition: floppy.c:2839
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
_In_ PUNICODE_STRING RegistryPath
Definition: wmip.h:27
NTSTATUS ScsiFlopStopDevice(IN PDEVICE_OBJECT Fdo, IN UCHAR Type)
Definition: floppy.c:2929
#define FILE_FLOPPY_DISKETTE
Definition: nt_native.h:809

◆ 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 2074 of file floppy.c.

2099 {
2100  PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
2101  DRIVE_MEDIA_TYPE driveMediaType;
2102  ULONG index;
2103 
2104  PAGED_CODE();
2105 
2106  //
2107  // Get the device type.
2108  //
2109 
2111 
2112  if (index == DRIVE_TYPE_NONE) {
2113 
2114  //
2115  // If the determine device type failed then just use the media type
2116  // and try the parameters.
2117  //
2118 
2119  driveMediaType = Drive360Media160;
2120 
2121  while (( DriveMediaConstants[driveMediaType].MediaType !=
2122  FormatParameters->MediaType ) &&
2123  ( driveMediaType < Drive288Media288) ) {
2124 
2125  driveMediaType++;
2126  }
2127 
2128  } else {
2129 
2130  //
2131  // Figure out which entry in the DriveMediaConstants table to use.
2132  //
2133 
2134  driveMediaType =
2136 
2137  while ( ( DriveMediaConstants[driveMediaType].MediaType !=
2138  FormatParameters->MediaType ) &&
2139  ( driveMediaType > DriveMediaLimits[index].
2140  LowestDriveMediaType ) ) {
2141 
2142  driveMediaType--;
2143  }
2144 
2145  }
2146 
2147 
2148  // driveMediaType is bounded below by DriveMediaLimits[].LowestDriveMediaType
2149 #ifdef _MSC_VER
2150 #pragma warning(push)
2151 #pragma warning(disable:33010) // 33010: Enum used as array index may be negative
2152 #endif
2153  if ( DriveMediaConstants[driveMediaType].MediaType !=
2154  FormatParameters->MediaType ) {
2155  return FALSE;
2156 
2157  } else {
2158 
2159  driveMediaConstants = &DriveMediaConstants[driveMediaType];
2160 
2161  if ( ( FormatParameters->StartHeadNumber >
2162  (ULONG)( driveMediaConstants->NumberOfHeads - 1 ) ) ||
2163  ( FormatParameters->EndHeadNumber >
2164  (ULONG)( driveMediaConstants->NumberOfHeads - 1 ) ) ||
2165  ( FormatParameters->StartCylinderNumber >
2166  driveMediaConstants->MaximumTrack ) ||
2167  ( FormatParameters->EndCylinderNumber >
2168  driveMediaConstants->MaximumTrack ) ||
2169  ( FormatParameters->EndCylinderNumber <
2170  FormatParameters->StartCylinderNumber ) ) {
2171 
2172  return FALSE;
2173 
2174  } else {
2175 
2176  return TRUE;
2177  }
2178  }
2179 #ifdef _MSC_VER
2180 #pragma warning(pop)
2181 #endif
2182 }
DRIVE_MEDIA_CONSTANTS DriveMediaConstants[]
Definition: floppy.c:173
#define TRUE
Definition: types.h:120
DRIVE_MEDIA_LIMITS DriveMediaLimits[NUMBER_OF_DRIVE_TYPES]
Definition: floppy.c:136
#define PAGED_CODE()
Definition: video.h:57
DRIVE_MEDIA_TYPE HighestDriveMediaType
Definition: floppy.c:121
GLuint index
Definition: glext.h:6031
enum _DRIVE_MEDIA_TYPE DRIVE_MEDIA_TYPE
#define index(s, c)
Definition: various.h:29
MEDIA_TYPE MediaType
Definition: floppy.c:153
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
ULONG DetermineDriveType(PDEVICE_OBJECT DeviceObject)
Definition: floppy.c:1913
#define DRIVE_TYPE_NONE
Definition: floppy.c:61
unsigned int ULONG
Definition: retypes.h:1

Referenced by ScsiFlopDeviceControl().

◆ FlopticalFormatMedia()

NTSTATUS FlopticalFormatMedia ( PDEVICE_OBJECT  DeviceObject,
PFORMAT_PARAMETERS  Format 
)

Definition at line 2721 of file floppy.c.

2744 {
2745  IO_STATUS_BLOCK ioStatus;
2746  PIRP irp;
2747  KEVENT event;
2749  ULONG length;
2750  PVOID buffer;
2751  PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
2752  NTSTATUS status;
2753 
2754  PAGED_CODE();
2755 
2756  driveMediaConstants = &DriveMediaConstants[Drive2080Media2080];
2757 
2758  //
2759  // Calculate the length of the buffer.
2760  //
2761 
2762  length = ((Format->EndCylinderNumber - Format->StartCylinderNumber) *
2763  driveMediaConstants->NumberOfHeads +
2764  Format->EndHeadNumber - Format->StartHeadNumber + 1) *
2765  driveMediaConstants->SectorsPerTrack *
2766  driveMediaConstants->BytesPerSector;
2767 
2768 #ifndef __REACTOS__
2769  buffer = ExAllocatePool(NonPagedPoolNxCacheAligned, length);
2770 #else
2772 #endif
2773 
2774  if (buffer == NULL) {
2776  }
2777 
2779 
2780  offset.QuadPart =
2781  (Format->StartCylinderNumber * driveMediaConstants->NumberOfHeads +
2782  Format->StartHeadNumber) * driveMediaConstants->SectorsPerTrack *
2783  driveMediaConstants->BytesPerSector;
2784 
2785  //
2786  // Set the event object to the unsignaled state.
2787  // It will be used to signal request completion.
2788  //
2789 
2791 
2792  //
2793  // Build the synchronous request with data transfer.
2794  //
2795 
2797  IRP_MJ_WRITE,
2798  DeviceObject,
2799  buffer,
2800  length,
2801  &offset,
2802  &event,
2803  &ioStatus);
2804 
2805  if (irp != NULL) {
2807 
2808  if (status == STATUS_PENDING) {
2809 
2810  //
2811  // Wait for the request to complete if necessary.
2812  //
2813 
2815  }
2816 
2817  //
2818  // If the call driver suceeded then set the status to the status block.
2819  //
2820 
2821  if (NT_SUCCESS(status)) {
2822  status = ioStatus.Status;
2823  }
2824  } else {
2826  }
2827 
2828  ExFreePool(buffer);
2829 
2830  return(status);
2831 
2832 }
DRIVE_MEDIA_CONSTANTS DriveMediaConstants[]
Definition: floppy.c:173
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
PIRP NTAPI IoBuildSynchronousFsdRequest(IN ULONG MajorFunction, IN PDEVICE_OBJECT DeviceObject, IN PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER StartingOffset, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:1069
LONG NTSTATUS
Definition: precomp.h:26
GLintptr offset
Definition: glext.h:5920
GLuint buffer
Definition: glext.h:5915
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
#define PAGED_CODE()
Definition: video.h:57
smooth NULL
Definition: ftsmooth.c:416
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
struct _cl_event * event
Definition: glext.h:7739
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
static SERVICE_STATUS status
Definition: service.c:31
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
Definition: ps.c:97

Referenced by ScsiFlopDeviceControl().

◆ FormatMedia()

NTSTATUS FormatMedia ( PDEVICE_OBJECT  DeviceObject,
MEDIA_TYPE  MediaType 
)

Definition at line 2185 of file floppy.c.

2209 {
2210  PVOID modeData;
2211  PSCSI_REQUEST_BLOCK srb;
2212  PMODE_FLEXIBLE_DISK_PAGE pageData;
2213  DRIVE_MEDIA_TYPE driveMediaType;
2214  PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
2215  ULONG length;
2216  NTSTATUS status;
2217 
2218  PAGED_CODE();
2219 
2220 #ifndef __REACTOS__
2221  modeData = ExAllocatePool(NonPagedPoolNxCacheAligned, MODE_DATA_SIZE);
2222 #else
2224 #endif
2225 
2226  if (modeData == NULL) {
2228  }
2229 
2230  RtlZeroMemory(modeData, MODE_DATA_SIZE);
2231 
2233  modeData,
2236 
2237  if (length < sizeof(MODE_PARAMETER_HEADER)) {
2238  ExFreePool(modeData);
2240  }
2241 
2242  //
2243  // Look for the flexible disk mode page.
2244  //
2245 
2246  pageData = ClassFindModePage( modeData, length, MODE_PAGE_FLEXIBILE, TRUE);
2247 
2248  //
2249  // Make sure the page is returned and is large enough.
2250  //
2251 
2252  if ((pageData == NULL) ||
2253  (pageData->PageLength + 2 <
2254  (UCHAR)offsetof(MODE_FLEXIBLE_DISK_PAGE, StartWritePrecom))) {
2255 
2256  ExFreePool(modeData);
2258 
2259  }
2260 
2261  //
2262  // Look for a drive media type which matches the requested media type.
2263  //
2264  //
2265  //start from Drive120MMedia120M instead of Drive2080Media2080
2266  //
2267  for (driveMediaType = Drive120MMedia120M;
2268  DriveMediaConstants[driveMediaType].MediaType != MediaType;
2269  driveMediaType--) {
2270  if (driveMediaType == Drive360Media160) {
2271 
2272  ExFreePool(modeData);
2273  return(STATUS_INVALID_PARAMETER);
2274 
2275  }
2276  }
2277 
2278  driveMediaConstants = &DriveMediaConstants[driveMediaType];
2279 
2280  if ((pageData->NumberOfHeads != driveMediaConstants->NumberOfHeads) ||
2281  (pageData->SectorsPerTrack != driveMediaConstants->SectorsPerTrack) ||
2282  ((pageData->NumberOfCylinders[0] != (UCHAR)((driveMediaConstants->MaximumTrack+1) >> 8)) &&
2283  (pageData->NumberOfCylinders[1] != (UCHAR)driveMediaConstants->MaximumTrack+1)) ||
2284  (pageData->BytesPerSector[0] != driveMediaConstants->BytesPerSector >> 8 )) {
2285 
2286  //
2287  // Update the flexible parameters page with the new parameters.
2288  //
2289 
2290  pageData->NumberOfHeads = driveMediaConstants->NumberOfHeads;
2291  pageData->SectorsPerTrack = driveMediaConstants->SectorsPerTrack;
2292  pageData->NumberOfCylinders[0] = (UCHAR)((driveMediaConstants->MaximumTrack+1) >> 8);
2293  pageData->NumberOfCylinders[1] = (UCHAR)driveMediaConstants->MaximumTrack+1;
2294  pageData->BytesPerSector[0] = driveMediaConstants->BytesPerSector >> 8;
2295 
2296  //
2297  // Clear the mode parameter header.
2298  //
2299 
2300  RtlZeroMemory(modeData, sizeof(MODE_PARAMETER_HEADER));
2301 
2302  //
2303  // Set the length equal to the length returned for the flexible page.
2304  //
2305 
2306  length = pageData->PageLength + 2;
2307 
2308  //
2309  // Copy the page after the mode parameter header.
2310  //
2311 
2312  RtlMoveMemory((PCHAR) modeData + sizeof(MODE_PARAMETER_HEADER),
2313  pageData,
2314  length
2315  );
2316  length += sizeof(MODE_PARAMETER_HEADER);
2317 
2318 
2319  //
2320  // Allocate a Srb for the format command.
2321  //
2322 
2323 #ifndef __REACTOS__
2324  srb = ExAllocatePool(NonPagedPoolNx, SCSI_REQUEST_BLOCK_SIZE);
2325 #else
2327 #endif
2328 
2329  if (srb == NULL) {
2330 
2331  ExFreePool(modeData);
2333  }
2334 
2336 
2337  srb->CdbLength = 6;
2338  srb->Cdb[0] = SCSIOP_MODE_SELECT;
2339  srb->Cdb[4] = (UCHAR) length;
2340 
2341  //
2342  // Set the PF bit.
2343  //
2344 
2345  srb->Cdb[1] |= 0x10;
2346 
2347  //
2348  // Set timeout value.
2349  //
2350 
2351  srb->TimeOutValue = 2;
2352 
2353  //
2354  // Send the mode select data.
2355  //
2356 
2358  srb,
2359  modeData,
2360  length,
2361  TRUE
2362  );
2363 
2364  //
2365  // The mode data not needed any more so free it.
2366  //
2367 
2368  ExFreePool(modeData);
2369 
2370  if (!NT_SUCCESS(status)) {
2371  ExFreePool(srb);
2372  return(status);
2373  }
2374 
2375  } else {
2376 
2377  //
2378  // The mode data not needed any more so free it.
2379  //
2380 
2381  ExFreePool(modeData);
2382 
2383  //
2384  // Allocate a Srb for the format command.
2385  //
2386 
2387 #ifndef __REACTOS__
2388  srb = ExAllocatePool(NonPagedPoolNx, SCSI_REQUEST_BLOCK_SIZE);
2389 #else
2391 #endif
2392 
2393  if (srb == NULL) {
2395  }
2396 
2397  }
2398 
2400 
2401  srb->CdbLength = 6;
2402 
2403  srb->Cdb[0] = SCSIOP_FORMAT_UNIT;
2404 
2405  //
2406  // Set timeout value.
2407  //
2408 
2409  srb->TimeOutValue = 10 * 60;
2410 
2412  srb,
2413  NULL,
2414  0,
2415  FALSE
2416  );
2417  ExFreePool(srb);
2418 
2419  return(status);
2420 
2421 }
signed char * PCHAR
Definition: retypes.h:7
DRIVE_MEDIA_CONSTANTS DriveMediaConstants[]
Definition: floppy.c:173
#define TRUE
Definition: types.h:120
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
UCHAR BytesPerSector[2]
Definition: scsi.h:2324
struct _MODE_PARAMETER_HEADER MODE_PARAMETER_HEADER
UCHAR Cdb[16]
Definition: srb.h:271
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
LONG NTSTATUS
Definition: precomp.h:26
ULONG NTAPI ClassModeSense(IN PDEVICE_OBJECT Fdo, IN PCHAR ModeSenseBuffer, IN ULONG Length, IN UCHAR PageMode)
Definition: class.c:4122
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
UCHAR CdbLength
Definition: srb.h:250
ULONG TimeOutValue
Definition: srb.h:254
#define PAGED_CODE()
Definition: video.h:57
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:263
NTSTATUS NTAPI ClassSendSrbSynchronous(PDEVICE_OBJECT Fdo, PSCSI_REQUEST_BLOCK Srb, PVOID BufferAddress, ULONG BufferLength, BOOLEAN WriteToDevice)
Definition: class.c:2648
smooth NULL
Definition: ftsmooth.c:416
#define offsetof(TYPE, MEMBER)
PVOID NTAPI ClassFindModePage(IN PCHAR ModeSenseBuffer, IN ULONG Length, IN UCHAR PageMode, IN BOOLEAN Use6Byte)
Definition: class.c:4209
enum _DRIVE_MEDIA_TYPE DRIVE_MEDIA_TYPE
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
#define MODE_DATA_SIZE
Definition: floppy.c:49
UCHAR NumberOfCylinders[2]
Definition: scsi.h:2325
unsigned char UCHAR
Definition: xmlstorage.h:181
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
#define SCSIOP_FORMAT_UNIT
Definition: cdrw_hw.h:871
MEDIA_TYPE MediaType
Definition: floppy.c:153
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
#define SCSI_REQUEST_BLOCK_SIZE
Definition: srb.h:274
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
static SERVICE_STATUS status
Definition: service.c:31
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define MODE_PAGE_FLEXIBILE
Definition: scsi.h:196
#define SCSIOP_MODE_SELECT
Definition: cdrw_hw.h:891
Definition: ps.c:97

Referenced by ScsiFlopDeviceControl().

◆ IsFloppyDevice()

BOOLEAN IsFloppyDevice ( PDEVICE_OBJECT  DeviceObject)

Definition at line 3145 of file disk.c.

3167 {
3168  PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
3169  PVOID modeData;
3170  PUCHAR pageData;
3171  ULONG length;
3172 
3173  PAGED_CODE();
3174 
3176 
3177  if (modeData == NULL) {
3178  return(FALSE);
3179  }
3180 
3181  RtlZeroMemory(modeData, MODE_DATA_SIZE);
3182 
3184  modeData,
3187 
3188  if (length < sizeof(MODE_PARAMETER_HEADER)) {
3189 
3190  //
3191  // Retry the request in case of a check condition.
3192  //
3193 
3195  modeData,
3198 
3199  if (length < sizeof(MODE_PARAMETER_HEADER)) {
3200 
3201  ExFreePool(modeData);
3202  return(FALSE);
3203 
3204  }
3205  }
3206 
3207  //
3208  // If the length is greater than length indicated by the mode data reset
3209  // the data to the mode data.
3210  //
3211 
3212  if (length > (ULONG) ((PMODE_PARAMETER_HEADER) modeData)->ModeDataLength + 1) {
3213  length = ((PMODE_PARAMETER_HEADER) modeData)->ModeDataLength + 1;
3214  }
3215 
3216  //
3217  // Look for the flexible disk mode page.
3218  //
3219 
3220  pageData = ScsiClassFindModePage( modeData, length, MODE_PAGE_FLEXIBILE, TRUE);
3221 
3222  if (pageData != NULL) {
3223 
3224  DebugPrint((1, "Scsidisk: Flexible disk page found, This is a floppy.\n"));
3225  ExFreePool(modeData);
3226  return(TRUE);
3227  }
3228 
3229  //
3230  // Check to see if the write cache is enabled.
3231  //
3232 
3233  pageData = ScsiClassFindModePage( modeData, length, MODE_PAGE_CACHING, TRUE);
3234 
3235  //
3236  // Assume that write cache is disabled or not supported.
3237  //
3238 
3239  deviceExtension->DeviceFlags &= ~DEV_WRITE_CACHE;
3240 
3241  //
3242  // Check if valid caching page exists.
3243  //
3244 
3245  if (pageData != NULL) {
3246 
3247  //
3248  // Check if write cache is disabled.
3249  //
3250 
3251  if (((PMODE_CACHING_PAGE)pageData)->WriteCacheEnable) {
3252 
3253  DebugPrint((1,
3254  "SCSIDISK: Disk write cache enabled\n"));
3255 
3256  //
3257  // Check if forced unit access (FUA) is supported.
3258  //
3259 
3260  if (((PMODE_PARAMETER_HEADER)modeData)->DeviceSpecificParameter & MODE_DSP_FUA_SUPPORTED) {
3261 
3262  deviceExtension->DeviceFlags |= DEV_WRITE_CACHE;
3263 
3264  } else {
3265 
3266  DebugPrint((1,
3267  "SCSIDISK: Disk does not support FUA or DPO\n"));
3268 
3269  //
3270  // TODO: Log this.
3271  //
3272 
3273  }
3274  }
3275  }
3276 
3277  ExFreePool(modeData);
3278  return(FALSE);
3279 
3280 } // end IsFloppyDevice()
#define TRUE
Definition: types.h:120
#define MODE_PAGE_CACHING
Definition: cdrw_hw.h:846
unsigned char * PUCHAR
Definition: retypes.h:3
#define MODE_SENSE_RETURN_ALL
Definition: cdrw_hw.h:857
#define PAGED_CODE()
Definition: video.h:57
#define DEV_WRITE_CACHE
Definition: class2.h:21
#define MODE_DATA_SIZE
Definition: disk.c:164
PVOID NTAPI ScsiClassFindModePage(IN PCHAR ModeSenseBuffer, IN ULONG Length, IN UCHAR PageMode, IN BOOLEAN Use6Byte)
Definition: class2.c:3610
PVOID DeviceExtension
Definition: env_spec_w32.h:418
smooth NULL
Definition: ftsmooth.c:416
struct _MODE_PARAMETER_HEADER * PMODE_PARAMETER_HEADER
ULONG NTAPI ScsiClassModeSense(IN PDEVICE_OBJECT DeviceObject, IN PCHAR ModeSenseBuffer, IN ULONG Length, IN UCHAR PageMode)
Definition: class2.c:3513
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
#define MODE_DSP_FUA_SUPPORTED
Definition: cdrw_hw.h:2522
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
ULONG NTAPI DebugPrint(IN PSTRING DebugString, IN ULONG ComponentId, IN ULONG Level)
Definition: debug.c:23
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define MODE_PAGE_FLEXIBILE
Definition: scsi.h:196

Referenced by ScsiFlopInitDevice().

◆ ScsiFlopAddDevice()

NTSTATUS ScsiFlopAddDevice ( IN PDRIVER_OBJECT  DriverObject,
IN PDEVICE_OBJECT  Pdo 
)

Definition at line 597 of file floppy.c.

620 {
623 
624  PAGED_CODE();
625 
626  //
627  // Get the number of disks already initialized.
628  //
629 
631 
632  if (NT_SUCCESS(status)) {
633 
634  //
635  // Increment system floppy device count.
636  //
637 
639  }
640 
641  return status;
642 }
_In_ PDEVICE_OBJECT Pdo
Definition: classpnp.h:301
PCONFIGURATION_INFORMATION NTAPI IoGetConfigurationInformation(VOID)
Definition: iorsrce.c:830
LONG NTSTATUS
Definition: precomp.h:26
#define PAGED_CODE()
Definition: video.h:57
static PDRIVER_OBJECT DriverObject
Definition: template.c:42
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSTATUS CreateFlopDeviceObject(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PortDeviceObject, IN ULONG DeviceCount)
Definition: floppy.c:645
unsigned int ULONG
Definition: retypes.h:1
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

◆ 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 1125 of file floppy.c.

1142 {
1143  KIRQL currentIrql;
1146  PSCSI_REQUEST_BLOCK srb;
1147  PCDB cdb;
1148  NTSTATUS status;
1149  PDISK_GEOMETRY outputBuffer;
1150  ULONG outputBufferLength;
1151  ULONG i;
1152  DRIVE_MEDIA_TYPE lowestDriveMediaType;
1153  DRIVE_MEDIA_TYPE highestDriveMediaType;
1154  PFORMAT_PARAMETERS formatParameters;
1155  PMODE_PARAMETER_HEADER modeData;
1156  ULONG length;
1157 
1158  //
1159  // Initialize the information field
1160  //
1161  Irp->IoStatus.Information = 0;
1162 
1163 #ifndef __REACTOS__
1164  srb = ExAllocatePool(NonPagedPoolNx, SCSI_REQUEST_BLOCK_SIZE);
1165 #else
1167 #endif
1168 
1169  if (srb == NULL) {
1170 
1171  Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
1172  if (IoIsErrorUserInduced(Irp->IoStatus.Status)) {
1173 
1175  }
1176 
1177  KeRaiseIrql(DISPATCH_LEVEL, &currentIrql);
1180  KeLowerIrql(currentIrql);
1181 
1183  }
1184 
1185  //
1186  // Write zeros to Srb.
1187  //
1188 
1190 
1191  cdb = (PCDB)srb->Cdb;
1192 
1193  switch (irpStack->Parameters.DeviceIoControl.IoControlCode) {
1194 
1195 
1196  case IOCTL_DISK_VERIFY: {
1197 
1198  PVERIFY_INFORMATION verifyInfo = Irp->AssociatedIrp.SystemBuffer;
1199  LARGE_INTEGER byteOffset;
1200  ULONG sectorOffset;
1202 
1203  //
1204  // Validate buffer length.
1205  //
1206 
1207  if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
1208  sizeof(VERIFY_INFORMATION)) {
1209 
1211  break;
1212  }
1213 
1214  //
1215  // Perform a bounds check on the sector range
1216  //
1217  if ((verifyInfo->StartingOffset.QuadPart > fdoExtension->CommonExtension.PartitionLength.QuadPart) ||
1218  (verifyInfo->StartingOffset.QuadPart < 0))
1219  {
1221  break;
1222  }
1223  else
1224  {
1225  ULONGLONG bytesRemaining = fdoExtension->CommonExtension.PartitionLength.QuadPart - verifyInfo->StartingOffset.QuadPart;
1226 
1227  if ((ULONGLONG)verifyInfo->Length > bytesRemaining)
1228  {
1230  break;
1231  }
1232  }
1233 
1234  //
1235  // Verify sectors
1236  //
1237 
1238  srb->CdbLength = 10;
1239 
1240  cdb->CDB10.OperationCode = SCSIOP_VERIFY;
1241 
1242  //
1243  // Add disk offset to starting sector.
1244  //
1245 
1246  byteOffset.QuadPart = fdoExtension->CommonExtension.StartingOffset.QuadPart +
1247  verifyInfo->StartingOffset.QuadPart;
1248 
1249  //
1250  // Convert byte offset to sector offset.
1251  //
1252 
1253  sectorOffset = (ULONG)(byteOffset.QuadPart >> fdoExtension->SectorShift);
1254 
1255  //
1256  // Convert ULONG byte count to USHORT sector count.
1257  //
1258 
1259  sectorCount = (USHORT)(verifyInfo->Length >> fdoExtension->SectorShift);
1260 
1261  //
1262  // Move little endian values into CDB in big endian format.
1263  //
1264 
1265  cdb->CDB10.LogicalBlockByte0 = ((PFOUR_BYTE)&sectorOffset)->Byte3;
1266  cdb->CDB10.LogicalBlockByte1 = ((PFOUR_BYTE)&sectorOffset)->Byte2;
1267  cdb->CDB10.LogicalBlockByte2 = ((PFOUR_BYTE)&sectorOffset)->Byte1;
1268  cdb->CDB10.LogicalBlockByte3 = ((PFOUR_BYTE)&sectorOffset)->Byte0;
1269 
1270  cdb->CDB10.TransferBlocksMsb = ((PFOUR_BYTE)&sectorCount)->Byte1;
1271  cdb->CDB10.TransferBlocksLsb = ((PFOUR_BYTE)&sectorCount)->Byte0;
1272 
1273  //
1274  // The verify command is used by the NT FORMAT utility and
1275  // requests are sent down for 5% of the volume size. The
1276  // request timeout value is calculated based on the number of
1277  // sectors verified.
1278  //
1279 
1280  srb->TimeOutValue = ((sectorCount + 0x7F) >> 7) *
1281  fdoExtension->TimeOutValue;
1282 
1284  srb,
1285  Irp,
1286  NULL,
1287  0,
1288  FALSE);
1289  return(status);
1290 
1291  }
1292 
1294 
1295  if (fdoExtension->AdapterDescriptor->BusType == BusTypeUsb) {
1296 
1298 
1299  // Don't need to propagate any error if one occurs
1300  //
1302 
1303  } else {
1304 
1306  }
1307 
1308  if (!NT_SUCCESS(status)) {
1309  // so will propogate error
1310  NOTHING;
1311  } else if (fdoExtension->DiskGeometry.MediaType == F3_120M_512) {
1312  //so that the format code will not try to partition it.
1314  } else {
1315  //
1316  // Free the Srb, since it is not needed.
1317  //
1318 
1319  ExFreePool(srb);
1320 
1321  //
1322  // Pass the request to the common device control routine.
1323  //
1324 
1326  }
1327  break;
1328  }
1329 
1331 
1332  DebugPrint((3,"ScsiDeviceIoControl: Get drive geometry\n"));
1333 
1334  if (fdoExtension->AdapterDescriptor->BusType == BusTypeUsb)
1335  {
1337  Irp);
1338  break;
1339  }
1340 
1341  //
1342  // If there's not enough room to write the
1343  // data, then fail the request.
1344  //
1345 
1346  if ( irpStack->Parameters.DeviceIoControl.OutputBufferLength <
1347  sizeof( DISK_GEOMETRY ) ) {
1348 
1350  break;
1351  }
1352 
1354 
1355  if (!NT_SUCCESS(status)) {
1356 
1357  Irp->IoStatus.Information = 0;
1358  Irp->IoStatus.Status = status;
1359 
1360  } else {
1361 
1362  //
1363  // Copy drive geometry information from device extension.
1364  //
1365 
1366  RtlMoveMemory(Irp->AssociatedIrp.SystemBuffer,
1367  &(fdoExtension->DiskGeometry),
1368  sizeof(DISK_GEOMETRY));
1369 
1370  Irp->IoStatus.Information = sizeof(DISK_GEOMETRY);
1372 
1373  }
1374 
1375  break;
1376  }
1377 
1379 
1380  if (fdoExtension->AdapterDescriptor->BusType == BusTypeUsb)
1381  {
1383  Irp);
1384  break;
1385  }
1386 
1388 
1389  if (i == DRIVE_TYPE_NONE) {
1391  break;
1392  }
1393 
1394  lowestDriveMediaType = DriveMediaLimits[i].LowestDriveMediaType;
1395  highestDriveMediaType = DriveMediaLimits[i].HighestDriveMediaType;
1396 
1397  outputBufferLength =
1398  irpStack->Parameters.DeviceIoControl.OutputBufferLength;
1399 
1400  //
1401  // Make sure that the input buffer has enough room to return
1402  // at least one descriptions of a supported media type.
1403  //
1404 
1405  if ( outputBufferLength < ( sizeof( DISK_GEOMETRY ) ) ) {
1406 
1408  break;
1409  }
1410 
1411  //
1412  // Assume success, although we might modify it to a buffer
1413  // overflow warning below (if the buffer isn't big enough
1414  // to hold ALL of the media descriptions).
1415  //
1416 
1418 
1419  if (outputBufferLength < ( sizeof( DISK_GEOMETRY ) *
1420  ( highestDriveMediaType - lowestDriveMediaType + 1 ) ) ) {
1421 
1422  //
1423  // The buffer is too small for all of the descriptions;
1424  // calculate what CAN fit in the buffer.
1425  //
1426 
1428 
1429  highestDriveMediaType = (DRIVE_MEDIA_TYPE)( ( lowestDriveMediaType - 1 ) +
1430  ( outputBufferLength /
1431  sizeof( DISK_GEOMETRY ) ) );
1432  }
1433 
1434  outputBuffer = (PDISK_GEOMETRY) Irp->AssociatedIrp.SystemBuffer;
1435 
1436  for (i = (UCHAR)lowestDriveMediaType;i <= (UCHAR)highestDriveMediaType;i++ ) {
1437 
1438  outputBuffer->MediaType = DriveMediaConstants[i].MediaType;
1439  outputBuffer->Cylinders.LowPart =
1441  outputBuffer->Cylinders.HighPart = 0;
1442  outputBuffer->TracksPerCylinder =
1444  outputBuffer->SectorsPerTrack =
1446  outputBuffer->BytesPerSector =
1448  outputBuffer++;
1449 
1450  Irp->IoStatus.Information += sizeof( DISK_GEOMETRY );
1451  }
1452 
1453  break;
1454  }
1455 
1456  case IOCTL_DISK_FORMAT_TRACKS: {
1457 
1458  if (fdoExtension->AdapterDescriptor->BusType == BusTypeUsb)
1459  {
1461  Irp);
1462  break;
1463  }
1464 
1465  //
1466  // Make sure that we got all the necessary format parameters.
1467  //
1468 
1469  if ( irpStack->Parameters.DeviceIoControl.InputBufferLength <sizeof( FORMAT_PARAMETERS ) ) {
1470 
1472  break;
1473  }
1474 
1475  formatParameters = (PFORMAT_PARAMETERS) Irp->AssociatedIrp.SystemBuffer;
1476 
1477  //
1478  // Make sure the parameters we got are reasonable.
1479  //
1480 
1481  if ( !FlCheckFormatParameters(DeviceObject, formatParameters)) {
1482 
1484  break;
1485  }
1486 
1487  //
1488  // If this request is for a 20.8 MB floppy then call a special
1489  // floppy format routine.
1490  //
1491 
1492  if (formatParameters->MediaType == F3_20Pt8_512) {
1494  formatParameters
1495  );
1496 
1497  break;
1498  }
1499 
1500  //
1501  // All the work is done in the pass. If this is not the first pass,
1502  // then complete the request and return;
1503  //
1504 
1505  if (formatParameters->StartCylinderNumber != 0 || formatParameters->StartHeadNumber != 0) {
1506 
1508  break;
1509  }
1510 
1511  status = FormatMedia( DeviceObject, formatParameters->MediaType);
1512  break;
1513  }
1514 
1515  case IOCTL_DISK_IS_WRITABLE: {
1516 
1517  if ((fdoExtension->DiskGeometry.MediaType) == F3_32M_512) {
1518 
1519  //
1520  // 32MB media is READ ONLY. Just return
1521  // STATUS_MEDIA_WRITE_PROTECTED
1522  //
1523 
1525 
1526  break;
1527  }
1528 
1529  //
1530  // Determine if the device is writable.
1531  //
1532 
1533 #ifndef __REACTOS__
1534  modeData = ExAllocatePool(NonPagedPoolNxCacheAligned, MODE_DATA_SIZE);
1535 #else
1537 #endif
1538 
1539  if (modeData == NULL) {
1541  break;
1542  }
1543 
1544  RtlZeroMemory(modeData, MODE_DATA_SIZE);
1545 
1547  (PCHAR) modeData,
1550 
1551  if (length < sizeof(MODE_PARAMETER_HEADER)) {
1552 
1553  //
1554  // Retry the request in case of a check condition.
1555  //
1556 
1558  (PCHAR) modeData,
1561 
1562  if (length < sizeof(MODE_PARAMETER_HEADER)) {
1564  ExFreePool(modeData);
1565  break;
1566  }
1567  }
1568 
1571  } else {
1573  }
1574 
1575  DebugPrint((2,"IOCTL_DISK_IS_WRITABLE returns %08X\n", status));
1576 
1577  ExFreePool(modeData);
1578  break;
1579  }
1580 
1581  default: {
1582 
1583  DebugPrint((3,"ScsiIoDeviceControl: Unsupported device IOCTL\n"));
1584 
1585  //
1586  // Free the Srb, since it is not needed.
1587  //
1588 
1589  ExFreePool(srb);
1590 
1591  //
1592  // Pass the request to the common device control routine.
1593  //
1594 
1596 
1597  break;
1598  }
1599 
1600  } // end switch( ...
1601 
1602  //
1603  // Check if SL_OVERRIDE_VERIFY_VOLUME flag is set in the IRP.
1604  // If so, do not return STATUS_VERIFY_REQUIRED
1605  //
1606  if ((status == STATUS_VERIFY_REQUIRED) &&
1607  (TEST_FLAG(irpStack->Flags, SL_OVERRIDE_VERIFY_VOLUME))) {
1608 
1610 
1611  }
1612 
1613  Irp->IoStatus.Status = status;
1614 
1616 
1618  }
1619 
1620  KeRaiseIrql(DISPATCH_LEVEL, &currentIrql);
1623  KeLowerIrql(currentIrql);
1624 
1625  ExFreePool(srb);
1626 
1627  return status;
1628 
1629 } // end ScsiFlopDeviceControl()
signed char * PCHAR
Definition: retypes.h:7
struct _FOUR_BYTE * PFOUR_BYTE
DRIVE_MEDIA_CONSTANTS DriveMediaConstants[]
Definition: floppy.c:173
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
NTSTATUS FormatMedia(PDEVICE_OBJECT DeviceObject, MEDIA_TYPE MediaType)
Definition: floppy.c:2185
UCHAR Cdb[16]
Definition: srb.h:271
#define TEST_FLAG(Flags, Bit)
Definition: classpnp.h:156
DISK_GEOMETRY DiskGeometry
Definition: classpnp.h:704
_In_ PIRP Irp
Definition: csq.h:116
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define MODE_DSP_WRITE_PROTECT
Definition: cdrw_hw.h:2523
DRIVE_MEDIA_LIMITS DriveMediaLimits[NUMBER_OF_DRIVE_TYPES]
Definition: floppy.c:136
#define IoIsErrorUserInduced(Status)
Definition: iofuncs.h:2769
Definition: cdrw_hw.h:28
LONG NTSTATUS
Definition: precomp.h:26
COMMON_DEVICE_EXTENSION CommonExtension
Definition: classpnp.h:695
ULONG NTAPI ClassModeSense(IN PDEVICE_OBJECT Fdo, IN PCHAR ModeSenseBuffer, IN ULONG Length, IN UCHAR PageMode)
Definition: class.c:4122
#define MODE_SENSE_RETURN_ALL
Definition: cdrw_hw.h:857
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define IOCTL_DISK_IS_WRITABLE
Definition: cdrw_usr.h:172
UCHAR CdbLength
Definition: srb.h:250
ULONG BytesPerSector
Definition: ntdddisk.h:376
ULONG TracksPerCylinder
Definition: ntdddisk.h:374
struct _CDB::_CDB10 CDB10
#define STATUS_VERIFY_REQUIRED
Definition: udferr_usr.h:130
ULONG TimeOutValue
Definition: srb.h:254
#define STATUS_NONEXISTENT_SECTOR
Definition: udferr_usr.h:143
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:64
#define STATUS_UNRECOGNIZED_MEDIA
Definition: udferr_usr.h:142
#define STATUS_IO_DEVICE_ERROR
Definition: udferr_usr.h:179
UCHAR KIRQL
Definition: env_spec_w32.h:591
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define IOCTL_DISK_FORMAT_TRACKS
Definition: cdrw_usr.h:171
#define IOCTL_DISK_VERIFY
Definition: cdrw_usr.h:170
DRIVE_MEDIA_TYPE HighestDriveMediaType
Definition: floppy.c:121
PVOID DeviceExtension
Definition: env_spec_w32.h:418
smooth NULL
Definition: ftsmooth.c:416
union _CDB * PCDB
UCHAR DeviceSpecificParameter
Definition: cdrw_hw.h:2507
#define SL_OVERRIDE_VERIFY_VOLUME
Definition: iotypes.h:1780
#define STATUS_MEDIA_WRITE_PROTECTED
Definition: udferr_usr.h:161
#define IOCTL_DISK_GET_MEDIA_TYPES
Definition: cdrw_usr.h:182
NTSTATUS USBFlopGetMediaTypes(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: floppy.c:2942
MEDIA_TYPE MediaType
Definition: ntdddisk.h:507
switch(r->id)
Definition: btrfs.c:2932
ULONG StartCylinderNumber
Definition: ntdddisk.h:508
if(!(yy_init))
Definition: macro.lex.yy.c:714
enum _DRIVE_MEDIA_TYPE DRIVE_MEDIA_TYPE
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
#define MODE_DATA_SIZE
Definition: floppy.c:49
uint64_t ULONGLONG
Definition: typedefs.h:65
LARGE_INTEGER Cylinders
Definition: ntdddisk.h:372
ULONG SectorsPerTrack
Definition: ntdddisk.h:375
PSTORAGE_ADAPTER_DESCRIPTOR AdapterDescriptor
Definition: classpnp.h:699
BOOLEAN FlCheckFormatParameters(IN PDEVICE_OBJECT DeviceObject, IN PFORMAT_PARAMETERS FormatParameters)
Definition: floppy.c:2074
#define for
Definition: utility.h:88
MEDIA_TYPE MediaType
Definition: ntdddisk.h:373
#define SCSIOP_VERIFY
Definition: cdrw_hw.h:912
unsigned char UCHAR
Definition: xmlstorage.h:181
struct _DISK_GEOMETRY * PDISK_GEOMETRY
#define IOCTL_DISK_GET_PARTITION_INFO
Definition: ntdddisk.h:88
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
ULONG LowPart
Definition: typedefs.h:104
#define NOTHING
Definition: env_spec_w32.h:461
ULONG NTAPI DebugPrint(IN PSTRING DebugString, IN ULONG ComponentId, IN ULONG Level)
Definition: debug.c:23
struct _FORMAT_PARAMETERS * PFORMAT_PARAMETERS
MEDIA_TYPE MediaType
Definition: floppy.c:153
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2745
struct _DISK_GEOMETRY DISK_GEOMETRY
VOID NTAPI ClassCompleteRequest(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN CCHAR PriorityBoost)
Definition: lock.c:376
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:61
unsigned short USHORT
Definition: pedump.c:61
ULONG DetermineDriveType(PDEVICE_OBJECT DeviceObject)
Definition: floppy.c:1913
#define SCSI_REQUEST_BLOCK_SIZE
Definition: srb.h:274
NTSTATUS FlopticalFormatMedia(PDEVICE_OBJECT DeviceObject, PFORMAT_PARAMETERS Format)
Definition: floppy.c:2721
DRIVE_MEDIA_TYPE LowestDriveMediaType
Definition: floppy.c:122
#define DRIVE_TYPE_NONE
Definition: floppy.c:61
UINT sectorCount[1]
Definition: diskio.c:16
unsigned int ULONG
Definition: retypes.h:1
NTSTATUS DetermineMediaType(PDEVICE_OBJECT DeviceObject)
Definition: floppy.c:1745
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
VOID NTAPI IoSetHardErrorOrVerifyDevice(IN PIRP Irp, IN PDEVICE_OBJECT DeviceObject)
Definition: util.c:316
NTSTATUS USBFlopFormatTracks(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: floppy.c:3320
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2772
return STATUS_SUCCESS
Definition: btrfs.c:2966
static SERVICE_STATUS status
Definition: service.c:31
NTSTATUS NTAPI ClassSendSrbAsynchronous(PDEVICE_OBJECT Fdo, PSCSI_REQUEST_BLOCK Srb, PIRP Irp, PVOID BufferAddress, ULONG BufferLength, BOOLEAN WriteToDevice)
Definition: class.c:4321
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define IOCTL_DISK_GET_DRIVE_GEOMETRY
Definition: cdrw_usr.h:169
LONGLONG QuadPart
Definition: typedefs.h:112
ULONG StartHeadNumber
Definition: ntdddisk.h:510
VOID NTAPI ClassReleaseRemoveLock(IN PDEVICE_OBJECT DeviceObject, IN OPTIONAL PIRP Tag)
Definition: lock.c:212
LARGE_INTEGER StartingOffset
Definition: ntdddisk.h:540
static DRIVER_DISPATCH ClassDeviceControl
Definition: kbdclass.c:22
Definition: ps.c:97

◆ ScsiFlopInitDevice()

NTSTATUS ScsiFlopInitDevice ( IN PDEVICE_OBJECT  Fdo)

Definition at line 820 of file floppy.c.

823 {
824  PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
825  PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
826  PDISK_DATA diskData = commonExtension->DriverData;
827 
828  PVOID senseData = NULL;
829  ULONG timeOut;
830 
832 
833  //
834  // Allocate request sense buffer.
835  //
836 
837 #ifndef __REACTOS__
838  senseData = ExAllocatePool(NonPagedPoolNxCacheAligned, SENSE_BUFFER_SIZE);
839 #else
841 #endif
842 
843  if (senseData == NULL) {
844 
845  //
846  // The buffer cannot be allocated.
847  //
848 
850  return status;
851  }
852 
853  //
854  // Set the sense data pointer in the device extension.
855  //
856 
857  fdoExtension->SenseData = senseData;
858 
859  //
860  // Build the lookaside list for srb's for this device.
861  //
862 
865 
866  //
867  // Register for media change notification
868  //
870  (PUCHAR) "SFloppy");
871 
872  //
873  // Set timeout value in seconds.
874  //
875 
876  timeOut = ClassQueryTimeOutRegistryValue(Fdo);
877  if (timeOut) {
878  fdoExtension->TimeOutValue = timeOut;
879  } else {
880  fdoExtension->TimeOutValue = SCSI_FLOPPY_TIMEOUT;
881  }
882 
883  //
884  // Floppies are not partitionable so starting offset is 0.
885  //
886 
887  fdoExtension->CommonExtension.StartingOffset.QuadPart = (LONGLONG)0;
888 
889 #if 0
890  if (!IsFloppyDevice(Fdo) ||
891  !(Fdo->Characteristics & FILE_REMOVABLE_MEDIA) ||
892  (fdoExtension->DeviceDescriptor->DeviceType != DIRECT_ACCESS_DEVICE)) {
893 
894  ExFreePool(senseData);
896  return status;
897  }
898 #endif
899 
900  RtlZeroMemory(&(fdoExtension->DiskGeometry),
901  sizeof(DISK_GEOMETRY));
902 
903  //
904  // Determine the media type if possible. Set the current media type to
905  // Unknown so that determine media type will check the media.
906  //
907 
908  fdoExtension->DiskGeometry.MediaType = Unknown;
909 
910  //
911  // Register interfaces for this device.
912  //
913 
914  {
915  UNICODE_STRING interfaceName;
916 
917  RtlInitUnicodeString(&interfaceName, NULL);
918 
919  status = IoRegisterDeviceInterface(fdoExtension->LowerPdo,
920  (LPGUID) &GUID_DEVINTERFACE_FLOPPY,
921  NULL,
922  &interfaceName);
923 
924  if(NT_SUCCESS(status)) {
925  diskData->FloppyInterfaceString = interfaceName;
926  } else {
928  DebugPrint((1, "ScsiFlopStartDevice: Unable to register device "
929  "interface for fdo %p [%08lx]\n",
930  Fdo, status));
931  }
932  }
933 
934  return (STATUS_SUCCESS);
935 }
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
DISK_GEOMETRY DiskGeometry
Definition: classpnp.h:704
unsigned char * PUCHAR
Definition: retypes.h:3
#define SFLOPPY_SRB_LIST_SIZE
Definition: floppy.c:51
LONG NTSTATUS
Definition: precomp.h:26
COMMON_DEVICE_EXTENSION CommonExtension
Definition: classpnp.h:695
BOOLEAN IsFloppyDevice(PDEVICE_OBJECT DeviceObject)
Definition: disk.c:3145
#define SENSE_BUFFER_SIZE
Definition: cdrw_hw.h:1183
#define FILE_REMOVABLE_MEDIA
Definition: nt_native.h:807
smooth NULL
Definition: ftsmooth.c:416
#define DIRECT_ACCESS_DEVICE
Definition: cdrw_hw.h:1144
int64_t LONGLONG
Definition: typedefs.h:66
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_NO_SUCH_DEVICE
Definition: udferr_usr.h:136
#define SCSI_FLOPPY_TIMEOUT
Definition: floppy.c:50
PSTORAGE_DEVICE_DESCRIPTOR DeviceDescriptor
Definition: classpnp.h:698
MEDIA_TYPE MediaType
Definition: ntdddisk.h:373
UNICODE_STRING FloppyInterfaceString
Definition: floppy.c:224
PDEVICE_OBJECT LowerPdo
Definition: classpnp.h:697
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
ULONG NTAPI DebugPrint(IN PSTRING DebugString, IN ULONG ComponentId, IN ULONG Level)
Definition: debug.c:23
NTSTATUS NTAPI IoRegisterDeviceInterface(IN PDEVICE_OBJECT PhysicalDeviceObject, IN CONST GUID *InterfaceClassGuid, IN PUNICODE_STRING ReferenceString OPTIONAL, OUT PUNICODE_STRING SymbolicLinkName)
Definition: deviface.c:955
ULONG NTAPI ClassQueryTimeOutRegistryValue(IN PDEVICE_OBJECT DeviceObject)
Definition: class.c:6190
VOID NTAPI ClassInitializeSrbLookasideList(IN PCOMMON_DEVICE_EXTENSION CommonExtension, IN ULONG NumberElements)
Definition: obsolete.c:941
VOID NTAPI ClassInitializeMediaChangeDetection(IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PUCHAR EventPrefix)
Definition: autorun.c:2058
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
return STATUS_SUCCESS
Definition: btrfs.c:2966
static SERVICE_STATUS status
Definition: service.c:31
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
Definition: ps.c:97

Referenced by DriverEntry().

◆ ScsiFlopProcessError()

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

Definition at line 2427 of file floppy.c.

2456 {
2458  PDISK_DATA diskData = (PDISK_DATA) fdoExtension->CommonExtension.DriverData;
2459  PSENSE_DATA senseBuffer = Srb->SenseInfoBuffer;
2460  PIO_STACK_LOCATION irpStack;
2461  PIRP irp;
2462  PSCSI_REQUEST_BLOCK srb;
2463  LARGE_INTEGER largeInt;
2465  PCDB cdb;
2466  ULONG_PTR alignment;
2467  ULONG majorFunction;
2468 
2471 
2472  largeInt.QuadPart = 1;
2473 
2474  //
2475  // Check the status. The initialization command only needs to be sent
2476  // if UNIT ATTENTION or LUN NOT READY is returned.
2477  //
2478 
2479  if (!(Srb->SrbStatus & SRB_STATUS_AUTOSENSE_VALID)) {
2480 
2481  //
2482  // The drive does not require reinitialization.
2483  //
2484 
2485  return;
2486  }
2487 
2488  //
2489  // Reset the drive type.
2490  //
2491 
2492  diskData->DriveType = DRIVE_TYPE_NONE;
2493  diskData->IsDMF = FALSE;
2494 
2495  fdoExtension->DiskGeometry.MediaType = Unknown;
2496 
2497  if (fdoExtension->AdapterDescriptor->BusType == BusTypeUsb) {
2498 
2499  // FLPYDISK.SYS never returns a non-zero value for the ChangeCount
2500  // on an IOCTL_DISK_CHECK_VERIFY. Some things seem to work better
2501  // if we do the same. In particular, FatVerifyVolume() can exit between
2502  // the IOCTL_DISK_CHECK_VERIFY and the IOCTL_DISK_GET_DRIVE_GEOMETRY
2503  // if a non-zero ChangeCount is returned, and this appears to cause
2504  // issues formatting unformatted media in some situations.
2505  //
2506  // This is something that should probably be revisited at some point.
2507  //
2508  fdoExtension->MediaChangeCount = 0;
2509 
2510  if (((senseBuffer->SenseKey & 0xf) == SCSI_SENSE_UNIT_ATTENTION) &&
2511  (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_MEDIUM_CHANGED)) {
2512 
2513  struct _START_STOP *startStopCdb;
2514 
2515  DebugPrint((2,"Sending SCSIOP_START_STOP_UNIT\n"));
2516 
2517 #ifndef __REACTOS__
2518  context = ExAllocatePool(NonPagedPoolNx,
2519  sizeof(COMPLETION_CONTEXT));
2520 #else
2522  sizeof(COMPLETION_CONTEXT));
2523 #endif
2524 
2525  if (context == NULL) {
2526 
2527  return;
2528  }
2529 #if (NTDDI_VERSION >= NTDDI_WIN8)
2530  srb = &context->Srb.Srb;
2531 #else
2532  srb = &context->Srb;
2533 #endif
2534 
2536 
2537  srb->SrbFlags = SRB_FLAGS_DISABLE_AUTOSENSE;
2538 
2539  srb->CdbLength = 6;
2540 
2541  startStopCdb = (struct _START_STOP *)srb->Cdb;
2542 
2543  startStopCdb->OperationCode = SCSIOP_START_STOP_UNIT;
2544  startStopCdb->Start = 1;
2545 
2546  // A Start Stop Unit request has no transfer buffer.
2547  // Set the request to IRP_MJ_FLUSH_BUFFERS when calling
2548  // IoBuildAsynchronousFsdRequest() so that it ignores
2549  // the buffer pointer and buffer length parameters.
2550  //
2551  majorFunction = IRP_MJ_FLUSH_BUFFERS;
2552 
2553  } else if ((senseBuffer->SenseKey & 0xf) == SCSI_SENSE_MEDIUM_ERROR) {
2554 
2555  // Return ERROR_UNRECOGNIZED_MEDIA instead of
2556  // STATUS_DEVICE_DATA_ERROR to make shell happy.
2557  //
2559  return;
2560 
2561  } else {
2562 
2563  return;
2564  }
2565 
2566 #ifndef __REACTOS__
2567  } else if (((senseBuffer->SenseKey & 0xf) == SCSI_SENSE_NOT_READY) &&
2568  senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_INIT_COMMAND_REQUIRED ||
2569  (senseBuffer->SenseKey & 0xf) == SCSI_SENSE_UNIT_ATTENTION) {
2570 #else
2571  } else if ((((senseBuffer->SenseKey & 0xf) == SCSI_SENSE_NOT_READY) &&
2572  senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_INIT_COMMAND_REQUIRED) ||
2573  (senseBuffer->SenseKey & 0xf) == SCSI_SENSE_UNIT_ATTENTION) {
2574 #endif
2575 
2576  ULONG sizeNeeded;
2577  ULONG tmpSize;
2578  BOOLEAN overFlow;
2579 
2580  DebugPrint((1, "ScsiFlopProcessError: Reinitializing the floppy.\n"));
2581 
2582  //
2583  // Send the special mode sense command to enable writes on the
2584  // floptical drive.
2585  //
2586 
2587  alignment = DeviceObject->AlignmentRequirement ?
2589 
2590  sizeNeeded = 0;
2591  overFlow = TRUE;
2592  if (SUCCEEDED(ULongAdd(sizeof(COMPLETION_CONTEXT), 0x2a, &tmpSize))) {
2593 
2594  if (SUCCEEDED(ULongAdd(tmpSize, (ULONG) alignment, &sizeNeeded))) {
2595  overFlow = FALSE;
2596  }
2597  }
2598 
2599  context = NULL;
2600 
2601  if (!overFlow) {
2602 #ifndef __REACTOS__
2603  context = ExAllocatePool(NonPagedPoolNx, sizeNeeded);
2604 #else
2605  context = ExAllocatePool(NonPagedPool, sizeNeeded);
2606 #endif
2607  }
2608 
2609  if (context == NULL) {
2610 
2611  //
2612  // If there is not enough memory to fulfill this request,
2613  // simply return. A subsequent retry will fail and another
2614  // chance to start the unit.
2615  //
2616 
2617  return;
2618  }
2619 
2620 #if (NTDDI_VERSION >= NTDDI_WIN8)
2621  srb = &context->Srb.Srb;
2622 #else
2623  srb = &context->Srb;
2624 #endif
2625 
2627 
2628  //
2629  // Set the transfer length.
2630  //
2631 
2632  srb->DataTransferLength = 0x2a;
2634 
2635  //
2636  // The data buffer must be aligned.
2637  //
2638 
2639  srb->DataBuffer = (PVOID) (((ULONG_PTR) (context + 1) + (alignment - 1)) &
2640  ~(alignment - 1));
2641 
2642 
2643  //
2644  // Build the start unit CDB.
2645  //
2646 
2647  srb->CdbLength = 6;
2648  cdb = (PCDB)srb->Cdb;
2649  cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
2650  cdb->MODE_SENSE.PageCode = 0x2e;
2651  cdb->MODE_SENSE.AllocationLength = 0x2a;
2652 
2653  majorFunction = IRP_MJ_READ;
2654 
2655  } else {
2656 
2657  return;
2658  }
2659 
2660  context->DeviceObject = DeviceObject;
2661 
2662  //
2663  // Write length to SRB.
2664  //
2665 
2666  srb->Length = SCSI_REQUEST_BLOCK_SIZE;
2667 
2668  srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
2669  srb->TimeOutValue = fdoExtension->TimeOutValue;
2670 
2671  //
2672  // Build the asynchronous request
2673  // to be sent to the port driver.
2674  //
2675 
2676  irp = IoBuildAsynchronousFsdRequest(majorFunction,
2677  DeviceObject,
2678  srb->DataBuffer,
2679  srb->DataTransferLength,
2680  &largeInt,
2681  NULL);
2682 
2683  if(irp == NULL) {
2685  return;
2686  }
2687 
2688 
2691  context,
2692  TRUE,
2693  TRUE,
2694  TRUE);
2695 
2697 
2698  irpStack = IoGetNextIrpStackLocation(irp);
2699 
2700  irpStack->MajorFunction = IRP_MJ_SCSI;
2701 
2702  srb->OriginalRequest = irp;
2703 
2704  //
2705  // Save SRB address in next stack for port driver.
2706  //
2707 
2708  irpStack->Parameters.Others.Argument1 = (PVOID)srb;
2709 
2710  //
2711  // Can't release the remove lock yet - let ClassAsynchronousCompletion
2712  // take care of that for us.
2713  //
2714 
2715  (VOID)IoCallDriver(fdoExtension->CommonExtension.LowerDeviceObject, irp);
2716 
2717  return;
2718 }
#define SRB_FLAGS_DISABLE_AUTOSENSE
Definition: srb.h:391
#define TRUE
Definition: types.h:120
#define ClassAcquireRemoveLock(devobj, tag)
Definition: classpnp.h:97
#define IRP_MJ_FLUSH_BUFFERS
Definition: http.c:6587
DISK_GEOMETRY DiskGeometry
Definition: classpnp.h:704
#define SRB_STATUS_AUTOSENSE_VALID
Definition: srb.h:379
#define SCSIOP_MODE_SENSE
Definition: cdrw_hw.h:896
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:323
Definition: cdrw_hw.h:28
COMMON_DEVICE_EXTENSION CommonExtension
Definition: classpnp.h:695
#define SRB_FLAGS_DATA_IN
Definition: srb.h:392
#define SCSI_SENSE_NOT_READY
Definition: cdrw_hw.h:1189
#define STATUS_UNRECOGNIZED_MEDIA
Definition: udferr_usr.h:142
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:515
uint32_t ULONG_PTR
Definition: typedefs.h:63
#define IRP_MJ_SCSI
#define SCSI_SENSE_MEDIUM_ERROR
Definition: cdrw_hw.h:1190
PVOID DeviceExtension
Definition: env_spec_w32.h:418
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
union _CDB * PCDB
IN PSCSI_REQUEST_BLOCK IN OUT NTSTATUS IN OUT BOOLEAN * Retry
Definition: class2.h:49
BOOLEAN IsDMF
Definition: floppy.c:222
struct _DISK_DATA * PDISK_DATA
void * PVOID
Definition: retypes.h:9
PSTORAGE_ADAPTER_DESCRIPTOR AdapterDescriptor
Definition: classpnp.h:699
#define SRB_FLAGS_DISABLE_SYNCH_TRANSFER
Definition: srb.h:389
PIRP NTAPI IoBuildAsynchronousFsdRequest(IN ULONG MajorFunction, IN PDEVICE_OBJECT DeviceObject, IN PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER StartingOffset, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:750
MEDIA_TYPE MediaType
Definition: ntdddisk.h:373
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
#define VOID
Definition: acefi.h:82
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2647
ULONG AlignmentRequirement
Definition: env_spec_w32.h:420
ULONG NTAPI DebugPrint(IN PSTRING DebugString, IN ULONG ComponentId, IN ULONG Level)
Definition: debug.c:23
Status
Definition: gdiplustypes.h:24
#define SCSI_SENSEQ_INIT_COMMAND_REQUIRED
Definition: cdrw_hw.h:1314
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
#define SCSI_REQUEST_BLOCK_SIZE
Definition: srb.h:274
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
IO_COMPLETION_ROUTINE * PIO_COMPLETION_ROUTINE
Definition: iotypes.h:2480
#define IRP_MJ_READ
Definition: rdpdr.c:46
#define DRIVE_TYPE_NONE
Definition: floppy.c:61
ULONG DriveType
Definition: floppy.c:221
#define SRB_FUNCTION_EXECUTE_SCSI
Definition: srb.h:307
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
IN PSCSI_REQUEST_BLOCK Srb
Definition: class2.h:49
NTSTATUS NTAPI ClassAsynchronousCompletion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
Definition: class.c:2168
#define SCSIOP_START_STOP_UNIT
Definition: cdrw_hw.h:897
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define SCSI_SENSE_UNIT_ATTENTION
Definition: cdrw_hw.h:1193
#define SUCCEEDED(hr)
Definition: intsafe.h:57
#define SCSI_ADSENSE_MEDIUM_CHANGED
Definition: cdrw_hw.h:1288

Referenced by DriverEntry().

◆ ScsiFlopReadWriteVerification()

NTSTATUS ScsiFlopReadWriteVerification ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 1085 of file floppy.c.

1102 {
1106 
1107  //
1108  // Make sure that the number of bytes to transfer is a multiple of the sector size
1109  //
1110  if ((irpSp->Parameters.Read.Length & (fdoExtension->DiskGeometry.BytesPerSector - 1)) != 0)
1111  {
1113  }
1114 
1115  Irp->IoStatus.Status = status;
1116 
1117  return status;
1118 }
DISK_GEOMETRY DiskGeometry
Definition: classpnp.h:704
_In_ PIRP Irp
Definition: csq.h:116
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
LONG NTSTATUS
Definition: precomp.h:26
ULONG BytesPerSector
Definition: ntdddisk.h:376
PVOID DeviceExtension
Definition: env_spec_w32.h:418
irpSp
Definition: iofuncs.h:2671
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2745
return STATUS_SUCCESS
Definition: btrfs.c:2966
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by DriverEntry().

◆ ScsiFlopRemoveDevice()

NTSTATUS ScsiFlopRemoveDevice ( IN PDEVICE_OBJECT  Fdo,
IN UCHAR  Type 
)

Definition at line 2839 of file floppy.c.

2867 {
2868  PFUNCTIONAL_DEVICE_EXTENSION deviceExtension =
2870  PDISK_DATA diskData = deviceExtension->CommonExtension.DriverData;
2871  NTSTATUS status;
2872 
2873  PAGED_CODE();
2874 
2875  if((Type == IRP_MN_QUERY_REMOVE_DEVICE) ||
2877  return STATUS_SUCCESS;
2878  }
2879 
2880  if (Type == IRP_MN_REMOVE_DEVICE){
2881  if(deviceExtension->DeviceDescriptor) {
2882  ExFreePool(deviceExtension->DeviceDescriptor);
2883  deviceExtension->DeviceDescriptor = NULL;
2884  }
2885 
2886  if(deviceExtension->AdapterDescriptor) {
2887  ExFreePool(deviceExtension->AdapterDescriptor);
2888  deviceExtension->AdapterDescriptor = NULL;
2889  }
2890 
2891  if(deviceExtension->SenseData) {
2892  ExFreePool(deviceExtension->SenseData);
2893  deviceExtension->SenseData = NULL;
2894  }
2895 
2896  ClassDeleteSrbLookasideList(&deviceExtension->CommonExtension);
2897  }
2898 
2899  if(diskData->FloppyInterfaceString.Buffer != NULL) {
2900 
2902  &(diskData->FloppyInterfaceString),
2903  FALSE);
2904 
2905  if (!NT_SUCCESS(status)) {
2906  // Failed to disable device interface during removal. Not a fatal error.
2907  DebugPrint((1, "ScsiFlopRemoveDevice: Unable to set device "
2908  "interface state to FALSE for fdo %p "
2909  "[%08lx]\n",
2910  DeviceObject, status));
2911  }
2912 
2915  }
2916 
2917  if(Type == IRP_MN_REMOVE_DEVICE) {
2919  }
2920 
2921  return STATUS_SUCCESS;
2922 }
#define IRP_MN_CANCEL_REMOVE_DEVICE
#define IRP_MN_REMOVE_DEVICE
VOID NTAPI ClassDeleteSrbLookasideList(IN PCOMMON_DEVICE_EXTENSION CommonExtension)
Definition: obsolete.c:899
Type
Definition: Type.h:6
PCONFIGURATION_INFORMATION NTAPI IoGetConfigurationInformation(VOID)
Definition: iorsrce.c:830
LONG NTSTATUS
Definition: precomp.h:26
COMMON_DEVICE_EXTENSION CommonExtension
Definition: classpnp.h:695
#define PAGED_CODE()
Definition: video.h:57
#define IRP_MN_QUERY_REMOVE_DEVICE
PVOID DeviceExtension
Definition: env_spec_w32.h:418
smooth NULL
Definition: ftsmooth.c:416
NTSTATUS NTAPI IoSetDeviceInterfaceState(IN PUNICODE_STRING SymbolicLinkName, IN BOOLEAN Enable)
Definition: deviface.c:1311
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
PSTORAGE_ADAPTER_DESCRIPTOR AdapterDescriptor
Definition: classpnp.h:699
PSTORAGE_DEVICE_DESCRIPTOR DeviceDescriptor
Definition: classpnp.h:698
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
UNICODE_STRING FloppyInterfaceString
Definition: floppy.c:224
ULONG NTAPI DebugPrint(IN PSTRING DebugString, IN ULONG ComponentId, IN ULONG Level)
Definition: debug.c:23
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
return STATUS_SUCCESS
Definition: btrfs.c:2966
static SERVICE_STATUS status
Definition: service.c:31
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
Definition: ps.c:97

Referenced by DriverEntry().

◆ ScsiFlopStartDevice()

NTSTATUS ScsiFlopStartDevice ( IN PDEVICE_OBJECT  Fdo)

Definition at line 943 of file floppy.c.

947 {
948  PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
949  PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
950 
951  PIRP irp;
952  IO_STATUS_BLOCK ioStatus;
953 
954  SCSI_ADDRESS scsiAddress;
955 
956  WCHAR ntNameBuffer[256];
957  UNICODE_STRING ntUnicodeString;
958 
959  WCHAR arcNameBuffer[256];
960  UNICODE_STRING arcUnicodeString;
961 
962  KEVENT event;
963 
965 
966  PAGED_CODE();
967 
969 
970  DetermineMediaType(Fdo); // ignore unsuccessful here
971 
972  //
973  // Create device object for this device.
974  //
975 
976  RtlStringCbPrintfW(ntNameBuffer,
977  sizeof(ntNameBuffer)/sizeof(WCHAR),
978  L"\\Device\\Floppy%u",
979  fdoExtension->DeviceNumber);
980 
981  //
982  // Create local copy of unicode string
983  //
984  RtlInitUnicodeString(&ntUnicodeString,ntNameBuffer);
985 
986  //
987  // Create a symbolic link from the disk name to the corresponding
988  // ARC name, to be used if we're booting off the disk. This will
989  // fail if it's not system initialization time; that's fine. The
990  // ARC name looks something like \ArcName\scsi(0)Flop(0)fdisk(0).
991  // In order to get the address, we need to send a IOCTL_SCSI_GET_ADDRESS...
992  //
993 
995  Fdo,
996  NULL,
997  0,
998  &scsiAddress,
999  sizeof(scsiAddress),
1000  FALSE,
1001  &event,
1002  &ioStatus);
1003 
1004  if (irp == NULL) {
1006  }
1007 
1008  status = IoCallDriver(fdoExtension->CommonExtension.LowerDeviceObject, irp);
1009 
1010  if (status == STATUS_PENDING) {
1012  status = ioStatus.Status;
1013  }
1014 
1015  //
1016  // IOCTL_SCSI_GET_ADDRESS might not be supported by the port driver and
1017  // hence may fail. But it is not a fatal error. Do not fail PnP start
1018  // if this IOCTL fails.
1019  //
1020  if (NT_SUCCESS(status)) {
1021 
1022  RtlStringCbPrintfW(arcNameBuffer,
1023  sizeof(arcNameBuffer)/sizeof(WCHAR),
1024  L"\\ArcName\\scsi(%u)disk(%u)fdisk(%u)",
1025  scsiAddress.PortNumber,
1026  scsiAddress.TargetId,
1027  scsiAddress.Lun);
1028 
1029  RtlInitUnicodeString(&arcUnicodeString, arcNameBuffer);
1030 
1031  IoAssignArcName(&arcUnicodeString, &ntUnicodeString);
1032  }
1033 
1035 
1036  //
1037  // Create the multi() arc name -- Create the "fake"
1038  // name of multi(0)disk(0)fdisk(#) to handle the case where the
1039  // SCSI floppy is the only floppy in the system. If this fails
1040  // it doesn't matter because the previous scsi() based ArcName
1041  // will work. This name is necessary for installation.
1042  //
1043 
1044  RtlStringCbPrintfW(arcNameBuffer,
1045  sizeof(arcNameBuffer)/sizeof(WCHAR),
1046  L"\\ArcName\\multi(%u)disk(%u)fdisk(%u)",
1047  0,
1048  0,
1049  fdoExtension->DeviceNumber);
1050 
1051  RtlInitUnicodeString(&arcUnicodeString, arcNameBuffer);
1052 
1053  IoAssignArcName(&arcUnicodeString, &ntUnicodeString);
1054 
1055  //
1056  // Set our interface state.
1057  //
1058 
1059  {
1060  PDISK_DATA diskData = commonExtension->DriverData;
1061 
1062  if(diskData->FloppyInterfaceString.Buffer != NULL) {
1063 
1065  &(diskData->FloppyInterfaceString),
1066  TRUE);
1067 
1068  if(!NT_SUCCESS(status)) {
1069  DebugPrint((1, "ScsiFlopStartDevice: Unable to set device "
1070  "interface state to TRUE for fdo %p "
1071  "[%08lx]\n",
1072  Fdo, status));
1073  }
1074  }
1075  }
1076 
1077  return STATUS_SUCCESS;
1078 }
UCHAR PortNumber
Definition: scsi_port.h:148
#define TRUE
Definition: types.h:120
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define IOCTL_SCSI_GET_ADDRESS
Definition: scsi_port.h:52
LONG NTSTATUS
Definition: precomp.h:26
COMMON_DEVICE_EXTENSION CommonExtension
Definition: classpnp.h:695
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
UCHAR TargetId
Definition: scsi_port.h:150
#define PAGED_CODE()
Definition: video.h:57
smooth NULL
Definition: ftsmooth.c:416
NTSTATUS NTAPI IoSetDeviceInterfaceState(IN PUNICODE_STRING SymbolicLinkName, IN BOOLEAN Enable)
Definition: deviface.c:1311
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
NTSTRSAFEVAPI RtlStringCbPrintfW(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cbDest, _In_ _Printf_format_string_ NTSTRSAFE_PCWSTR pszFormat,...)
Definition: ntstrsafe.h:1173
UNICODE_STRING FloppyInterfaceString
Definition: floppy.c:224
static const WCHAR L[]
Definition: oid.c:1250
struct _cl_event * event
Definition: glext.h:7739
ULONG NTAPI DebugPrint(IN PSTRING DebugString, IN ULONG ComponentId, IN ULONG Level)
Definition: debug.c:23
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define IoAssignArcName(_ArcName, _DeviceName)
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
NTSTATUS DetermineMediaType(PDEVICE_OBJECT DeviceObject)
Definition: floppy.c:1745
return STATUS_SUCCESS
Definition: btrfs.c:2966
Definition: ps.c:97

Referenced by DriverEntry().

◆ ScsiFlopStopDevice()

NTSTATUS ScsiFlopStopDevice ( IN PDEVICE_OBJECT  Fdo,
IN UCHAR  Type 
)

Definition at line 2929 of file floppy.c.

2933 {
2936 
2937  return STATUS_SUCCESS;
2938 }
Type
Definition: Type.h:6
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:323
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
return STATUS_SUCCESS
Definition: btrfs.c:2966

Referenced by DriverEntry().

◆ ScsiFlopUnload()

VOID ScsiFlopUnload ( IN PDRIVER_OBJECT  DriverObject)

Definition at line 568 of file floppy.c.

571 {
572  PAGED_CODE();
574  return;
575 }
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:323
#define PAGED_CODE()
Definition: video.h:57
static PDRIVER_OBJECT DriverObject
Definition: template.c:42

◆ USBFlopFormatTracks()

NTSTATUS USBFlopFormatTracks ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 3320 of file floppy.c.

3324 {
3325 /*++
3326 
3327 Routine Description:
3328 
3329  This routines formats the specified tracks. If multiple tracks are
3330  specified, each is formatted with a separate Format Unit request.
3331 
3332 Arguments:
3333 
3334  DeviceObject - Supplies the device object.
3335 
3336  Irp - A IOCTL_DISK_FORMAT_TRACKS Irp.
3337 
3338 Return Value:
3339 
3340  Status is returned.
3341 
3342 --*/
3343  PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
3344  PIO_STACK_LOCATION irpStack;
3345  PFORMAT_PARAMETERS formatParameters;
3346  PDISK_GEOMETRY geometry;
3347  PFORMATTED_CAPACITY capacity;
3348  PSCSI_REQUEST_BLOCK srb;
3349  PFORMAT_UNIT_PARAMETER_LIST parameterList;
3350  PCDB12FORMAT cdb;
3351  ULONG i;
3352  ULONG cylinder, head;
3354 
3355  PAGED_CODE();
3356 
3357  fdoExtension = DeviceObject->DeviceExtension;
3358 
3359  // Get the Irp parameters
3360  //
3361  irpStack = IoGetCurrentIrpStackLocation(Irp);
3362 
3363  if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
3364  sizeof(FORMAT_PARAMETERS))
3365  {
3366  return STATUS_INVALID_PARAMETER;
3367  }
3368 
3369  formatParameters = (PFORMAT_PARAMETERS)Irp->AssociatedIrp.SystemBuffer;
3370 
3371  // Find the geometry / capacity entries corresponding to the format
3372  // parameters MediaType
3373  //
3374  geometry = NULL;
3375  capacity = NULL;
3376 
3377  for (i=0; i<FLOPPY_CAPACITIES; i++)
3378  {
3379  if (FloppyGeometries[i].MediaType == formatParameters->MediaType)
3380  {
3381  geometry = &FloppyGeometries[i];
3382  capacity = &FloppyCapacities[i];
3383 
3384  break;
3385  }
3386  }
3387 
3388  if (geometry == NULL)
3389  {
3390  return STATUS_INVALID_PARAMETER;
3391  }
3392 
3393  // Check if the format parameters are valid
3394  //
3395  if ((formatParameters->StartCylinderNumber >
3396  geometry->Cylinders.LowPart - 1) ||
3397 
3398  (formatParameters->EndCylinderNumber >
3399  geometry->Cylinders.LowPart - 1) ||
3400 
3401  (formatParameters->StartHeadNumber >
3402  geometry->TracksPerCylinder - 1) ||
3403 
3404  (formatParameters->EndHeadNumber >
3405  geometry->TracksPerCylinder - 1) ||
3406 
3407  (formatParameters->StartCylinderNumber >
3408  formatParameters->EndCylinderNumber) ||
3409 
3410  (formatParameters->StartHeadNumber >
3411  formatParameters->EndHeadNumber))
3412  {
3413  return STATUS_INVALID_PARAMETER;
3414  }
3415 
3416  // Don't low level format LS-120 media, Imation says it's best to not
3417  // do this.
3418  //
3419  if ((formatParameters->MediaType == F3_120M_512) ||
3420  (formatParameters->MediaType == F3_240M_512) ||
3421  (formatParameters->MediaType == F3_32M_512))
3422  {
3423  return STATUS_SUCCESS;
3424  }
3425 
3426  // Allocate an SRB for the SCSIOP_FORMAT_UNIT request
3427  //
3428 #ifndef __REACTOS__
3429  srb = ExAllocatePool(NonPagedPoolNx, SCSI_REQUEST_BLOCK_SIZE);
3430 #else
3432 #endif
3433 
3434  if (srb == NULL)
3435  {
3437  }
3438 
3439  // Allocate a transfer buffer for the SCSIOP_FORMAT_UNIT parameter list
3440  //
3441 #ifndef __REACTOS__
3442  parameterList = ExAllocatePool(NonPagedPoolNx,
3443  sizeof(FORMAT_UNIT_PARAMETER_LIST));
3444 #else
3445  parameterList = ExAllocatePool(NonPagedPool,
3446  sizeof(FORMAT_UNIT_PARAMETER_LIST));
3447 #endif
3448 
3449  if (parameterList == NULL)
3450  {
3451  ExFreePool(srb);
3453  }
3454 
3455  // Initialize the parameter list
3456  //
3457  RtlZeroMemory(parameterList, sizeof(FORMAT_UNIT_PARAMETER_LIST));
3458 
3459  parameterList->DefectListHeader.SingleTrack = 1;
3460  parameterList->DefectListHeader.DisableCert = 1; // TEAC requires this set
3461  parameterList->DefectListHeader.FormatOptionsValid = 1;
3462  parameterList->DefectListHeader.DefectListLengthLsb = 8;
3463 
3464  parameterList->FormatDescriptor.NumberOfBlocks[0] =
3465  (UCHAR)((capacity->NumberOfBlocks >> 24) & 0xFF);
3466 
3467  parameterList->FormatDescriptor.NumberOfBlocks[1] =
3468  (UCHAR)((capacity->NumberOfBlocks >> 16) & 0xFF);
3469 
3470  parameterList->FormatDescriptor.NumberOfBlocks[2] =
3471  (UCHAR)((capacity->NumberOfBlocks >> 8) & 0xFF);
3472 
3473  parameterList->FormatDescriptor.NumberOfBlocks[3] =
3474  (UCHAR)(capacity->NumberOfBlocks & 0xFF);
3475 
3476  parameterList->FormatDescriptor.BlockLength[0] =
3477  (UCHAR)((capacity->BlockLength >> 16) & 0xFF);
3478 
3479  parameterList->FormatDescriptor.BlockLength[1] =
3480  (UCHAR)((capacity->BlockLength >> 8) & 0xFF);
3481 
3482  parameterList->FormatDescriptor.BlockLength[2] =
3483  (UCHAR)(capacity->BlockLength & 0xFF);
3484 
3485 
3486  for (cylinder = formatParameters->StartCylinderNumber;
3487  cylinder <= formatParameters->EndCylinderNumber;
3488  cylinder++)
3489  {
3490  for (head = formatParameters->StartHeadNumber;
3491  head <= formatParameters->EndHeadNumber;
3492  head++)
3493  {
3494  // Initialize the SRB and CDB
3495  //
3497 
3498  srb->CdbLength = sizeof(CDB12FORMAT);
3499 
3500  srb->TimeOutValue = fdoExtension->TimeOutValue;
3501 
3502  cdb = (PCDB12FORMAT)srb->Cdb;
3503 
3505  cdb->DefectListFormat = 7;
3506  cdb->FmtData = 1;
3507  cdb->TrackNumber = (UCHAR)cylinder;
3509 
3510  parameterList->DefectListHeader.Side = (UCHAR)head;
3511 
3512  //
3513  // Send down the SCSIOP_FORMAT_UNIT request
3514  //
3516  srb,
3517  parameterList,
3519  TRUE);
3520 
3521  if (!NT_SUCCESS(status))
3522  {
3523  break;
3524  }
3525  }
3526  if (!NT_SUCCESS(status))
3527  {
3528  break;
3529  }
3530  }
3531 
3532  if (NT_SUCCESS(status) && formatParameters->StartCylinderNumber == 0)
3533  {
3534  // Update the device geometry
3535  //
3536 
3537  DebugPrint((2,"geometry was: %3d %2d %d %2d %4d %2d %08X\n",
3538  fdoExtension->DiskGeometry.Cylinders.LowPart,
3539  fdoExtension->DiskGeometry.MediaType,
3540  fdoExtension->DiskGeometry.TracksPerCylinder,
3541  fdoExtension->DiskGeometry.SectorsPerTrack,
3542  fdoExtension->DiskGeometry.BytesPerSector,
3543  fdoExtension->SectorShift,
3544  fdoExtension->CommonExtension.PartitionLength.LowPart));
3545 
3546  fdoExtension->DiskGeometry = *geometry;
3547 
3548  //
3549  // Calculate sector to byte shift.
3550  //
3551 
3552  WHICH_BIT(fdoExtension->DiskGeometry.BytesPerSector,
3553  fdoExtension->SectorShift);
3554 
3555  fdoExtension->CommonExtension.PartitionLength.QuadPart =
3556  (LONGLONG)capacity->NumberOfBlocks *
3557  capacity->BlockLength;
3558 
3559  DebugPrint((2,"geometry is: %3d %2d %d %2d %4d %2d %08X\n",
3560  fdoExtension->DiskGeometry.Cylinders.LowPart,
3561  fdoExtension->DiskGeometry.MediaType,
3562  fdoExtension->DiskGeometry.TracksPerCylinder,
3563  fdoExtension->DiskGeometry.SectorsPerTrack,
3564  fdoExtension->DiskGeometry.BytesPerSector,
3565  fdoExtension->SectorShift,
3566  fdoExtension->CommonExtension.PartitionLength.LowPart));
3567  }
3568 
3569  // Free everything we allocated
3570  //
3571  ExFreePool(parameterList);
3572  ExFreePool(srb);
3573 
3574  return status;
3575 }
#define TRUE
Definition: types.h:120
#define FLOPPY_CAPACITIES
Definition: floppy.c:292
FORMATTED_CAPACITY FloppyCapacities[]
Definition: floppy.c:249
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
UCHAR Cdb[16]
Definition: srb.h:271
struct outqueuenode * head
Definition: adnsresfilter.c:66
DISK_GEOMETRY DiskGeometry
Definition: classpnp.h:704
_In_ PIRP Irp
Definition: csq.h:116
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
GLUquadricObj * cylinder
Definition: cylfrac.c:44
LONG NTSTATUS
Definition: precomp.h:26
COMMON_DEVICE_EXTENSION CommonExtension
Definition: classpnp.h:695
ULONG NumberOfBlocks
Definition: floppy.c:240
struct _CDB12FORMAT CDB12FORMAT
UCHAR CdbLength
Definition: srb.h:250
ULONG BytesPerSector
Definition: ntdddisk.h:376
ULONG TracksPerCylinder
Definition: ntdddisk.h:374
ULONG TimeOutValue
Definition: srb.h:254
#define WHICH_BIT(Data, Bit)
Definition: tools.h:80
#define PAGED_CODE()
Definition: video.h:57
UCHAR ParameterListLengthLsb
Definition: floppy.c:314
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
NTSTATUS NTAPI ClassSendSrbSynchronous(PDEVICE_OBJECT Fdo, PSCSI_REQUEST_BLOCK Srb, PVOID BufferAddress, ULONG BufferLength, BOOLEAN WriteToDevice)
Definition: class.c:2648
DEFECT_LIST_HEADER DefectListHeader
Definition: floppy.c:335
PVOID DeviceExtension
Definition: env_spec_w32.h:418
smooth NULL
Definition: ftsmooth.c:416
MEDIA_TYPE MediaType
Definition: ntdddisk.h:507
ULONG StartCylinderNumber
Definition: ntdddisk.h:508
UCHAR DefectListLengthLsb
Definition: floppy.c:330
int64_t LONGLONG
Definition: typedefs.h:66
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
LARGE_INTEGER Cylinders
Definition: ntdddisk.h:372
ULONG SectorsPerTrack
Definition: ntdddisk.h:375
#define for
Definition: utility.h:88
MEDIA_TYPE MediaType
Definition: ntdddisk.h:373
unsigned char UCHAR
Definition: xmlstorage.h:181
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
ULONG LowPart
Definition: typedefs.h:104
#define SCSIOP_FORMAT_UNIT
Definition: cdrw_hw.h:871
ULONG NTAPI DebugPrint(IN PSTRING DebugString, IN ULONG ComponentId, IN ULONG Level)
Definition: debug.c:23
struct _FORMAT_PARAMETERS * PFORMAT_PARAMETERS
FORMATTED_CAPACITY_DESCRIPTOR FormatDescriptor
Definition: floppy.c:336
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2745
UCHAR FmtData
Definition: floppy.c:307
#define SCSI_REQUEST_BLOCK_SIZE
Definition: srb.h:274
UCHAR FormatOptionsValid
Definition: floppy.c:328
DISK_GEOMETRY FloppyGeometries[]
Definition: floppy.c:264
UCHAR OperationCode
Definition: floppy.c:304
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
ULONG EndCylinderNumber
Definition: ntdddisk.h:509
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2772
return STATUS_SUCCESS
Definition: btrfs.c:2966
static SERVICE_STATUS status
Definition: service.c:31
struct _FORMAT_UNIT_PARAMETER_LIST FORMAT_UNIT_PARAMETER_LIST
UCHAR DefectListFormat
Definition: floppy.c:305
struct _CDB12FORMAT * PCDB12FORMAT
UCHAR TrackNumber
Definition: floppy.c:309
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
ULONG StartHeadNumber
Definition: ntdddisk.h:510
Definition: ps.c:97

Referenced by ScsiFlopDeviceControl().

◆ USBFlopGetMediaTypes()

NTSTATUS USBFlopGetMediaTypes ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 2942 of file floppy.c.

2946 {
2947 /*++
2948 
2949 Routine Description:
2950 
2951  This routines determines the current or default geometry of the drive
2952  for IOCTL_DISK_GET_DRIVE_GEOMETRY, or all currently supported geometries
2953  of the drive (which is determined by its currently inserted media) for
2954  IOCTL_DISK_GET_MEDIA_TYPES.
2955 
2956  The returned geometries are determined by issuing a Read Format Capacities
2957  request and then matching the returned {Number of Blocks, Block Length}
2958  pairs in a table of known floppy geometries.
2959 
2960 Arguments:
2961 
2962  DeviceObject - Supplies the device object.
2963 
2964  Irp - A IOCTL_DISK_GET_DRIVE_GEOMETRY or a IOCTL_DISK_GET_MEDIA_TYPES Irp.
2965  If NULL, the device geometry is updated with the current device
2966  geometry.
2967 
2968 Return Value:
2969 
2970  Status is returned.
2971 
2972 --*/
2973  PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
2974  PIO_STACK_LOCATION irpStack;
2975  ULONG ioControlCode;
2976  PDISK_GEOMETRY outputBuffer;
2977  PDISK_GEOMETRY outputBufferEnd;
2978  ULONG outputBufferLength;
2979  PSCSI_REQUEST_BLOCK srb;
2980  PVOID dataBuffer;
2981  ULONG dataTransferLength;
2982  struct _READ_FORMATTED_CAPACITIES *cdb;
2983  PFORMATTED_CAPACITY_LIST capList;
2984  NTSTATUS status;
2985 
2986  PAGED_CODE();
2987 
2988  fdoExtension = DeviceObject->DeviceExtension;
2989 
2990  if (Irp != NULL) {
2991 
2992  // Get the Irp parameters
2993  //
2994  irpStack = IoGetCurrentIrpStackLocation(Irp);
2995 
2996  ioControlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;
2997 
2998  Irp->IoStatus.Information = 0;
2999 
3000  outputBuffer = (PDISK_GEOMETRY) Irp->AssociatedIrp.SystemBuffer;
3001 
3002  outputBufferLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
3003 
3004  if (outputBufferLength < sizeof(DISK_GEOMETRY))
3005  {
3006  return STATUS_BUFFER_TOO_SMALL;
3007  }
3008 
3009  // Pointer arithmetic to allow multiple DISK_GEOMETRY's to be returned.
3010  // Rounds BufferEnd down to integral multiple of DISK_GEOMETRY structs.
3011  //
3012  outputBufferEnd = outputBuffer +
3013  outputBufferLength / sizeof(DISK_GEOMETRY);
3014 
3015  } else {
3016 
3017  // No Irp to return the result in, just update the current geometry
3018  // in the device extension.
3019  //
3020  ioControlCode = IOCTL_DISK_GET_DRIVE_GEOMETRY;
3021 
3022  outputBuffer = NULL;
3023 
3024  outputBufferEnd = NULL;
3025 
3026  outputBufferLength = 0;
3027  }
3028 
3029  if (ioControlCode == IOCTL_DISK_GET_DRIVE_GEOMETRY) {
3030 
3031  fdoExtension->DiskGeometry.MediaType = Unknown;
3032 
3034 
3035  if (!NT_SUCCESS(status))
3036  {
3037  // If the media is not recongized, we want to return the default
3038  // geometry so that the media can be formatted. Unrecognized media
3039  // causes SCSI_SENSE_MEDIUM_ERROR, which gets reported as
3040  // STATUS_DEVICE_DATA_ERROR. Ignore these errors, but return other
3041  // errors, such as STATUS_NO_MEDIA_IN_DEVICE.
3042  //
3044  {
3045  DebugPrint((2,"IOCTL_DISK_GET_DRIVE_GEOMETRY returns %08X\n", status));
3046 
3047  return status;
3048  }
3049  }
3050  }
3051 
3052  // Allocate an SRB for the SCSIOP_READ_FORMATTED_CAPACITY request
3053  //
3054 #ifndef __REACTOS__
3055  srb = ExAllocatePool(NonPagedPoolNx, SCSI_REQUEST_BLOCK_SIZE);
3056 #else
3058 #endif
3059 
3060  if (srb == NULL)
3061  {
3063  }
3064 
3065  // Allocate a transfer buffer for the SCSIOP_READ_FORMATTED_CAPACITY request
3066  // The length of the returned descriptor array is limited to a byte field
3067  // in the capacity list header.
3068  //
3069  dataTransferLength = sizeof(FORMATTED_CAPACITY_LIST) +
3070  31 * sizeof(FORMATTED_CAPACITY_DESCRIPTOR);
3071 
3072  ASSERT(dataTransferLength < 0x100);
3073 
3074 #ifndef __REACTOS__
3075  dataBuffer = ExAllocatePool(NonPagedPoolNx, dataTransferLength);
3076 #else
3077  dataBuffer = ExAllocatePool(NonPagedPool, dataTransferLength);
3078 #endif
3079 
3080  if (dataBuffer == NULL)
3081  {
3082  ExFreePool(srb);
3084  }
3085 
3086  // Initialize the SRB and CDB
3087  //
3089 
3090  RtlZeroMemory(dataBuffer, dataTransferLength);
3091 
3092  srb->CdbLength = sizeof(struct _READ_FORMATTED_CAPACITIES);
3093 
3094  srb->TimeOutValue = fdoExtension->TimeOutValue;
3095 
3096  cdb = (struct _READ_FORMATTED_CAPACITIES *)srb->Cdb;
3097 
3098  cdb->OperationCode = SCSIOP_READ_FORMATTED_CAPACITY;
3099  cdb->AllocationLength[1] = (UCHAR)dataTransferLength;
3100 
3101  //
3102  // Send down the SCSIOP_READ_FORMATTED_CAPACITY request
3103  //
3105  srb,
3106  dataBuffer,
3107  dataTransferLength,
3108  FALSE);
3109 
3110  capList = (PFORMATTED_CAPACITY_LIST)dataBuffer;
3111 
3112  // If we don't get as much data as requested, it is not an error.
3113  //
3115  {
3117  }
3118 
3119  if (NT_SUCCESS(status) &&
3120  srb->DataTransferLength >= sizeof(FORMATTED_CAPACITY_LIST) &&
3121  capList->CapacityListLength &&
3122  capList->CapacityListLength % sizeof(FORMATTED_CAPACITY_DESCRIPTOR) == 0)
3123  {
3124  ULONG NumberOfBlocks;
3125  ULONG BlockLength;
3126  ULONG count;
3127  ULONG i, j;
3128  LONG currentGeometry;
3129  BOOLEAN capacityMatches[FLOPPY_CAPACITIES];
3130 
3131  // Subtract the size of the Capacity List Header to get
3132  // just the size of the Capacity List Descriptor array.
3133  //
3135 
3136  // Only look at the Capacity List Descriptors that were actually
3137  // returned.
3138  //
3139  if (srb->DataTransferLength < capList->CapacityListLength)
3140  {
3141  count = srb->DataTransferLength /
3143  }
3144  else
3145  {
3146  count = capList->CapacityListLength /
3148  }
3149 
3150  // Updated only if a match is found for the first Capacity List
3151  // Descriptor returned by the device.
3152  //
3153  currentGeometry = -1;
3154 
3155  // Initialize the array of capacities that hit a match.
3156  //
3157  RtlZeroMemory(capacityMatches, sizeof(capacityMatches));
3158 
3159  // Iterate over each Capacity List Descriptor returned from the device
3160  // and record matching capacities in the capacity match array.
3161  //
3162  for (i = 0; i < count; i++)
3163  {
3164  NumberOfBlocks = (capList->Descriptors[i].NumberOfBlocks[0] << 24) +
3165  (capList->Descriptors[i].NumberOfBlocks[1] << 16) +
3166  (capList->Descriptors[i].NumberOfBlocks[2] << 8) +
3167  (capList->Descriptors[i].NumberOfBlocks[3]);
3168 
3169  BlockLength = (capList->Descriptors[i].BlockLength[0] << 16) +
3170  (capList->Descriptors[i].BlockLength[1] << 8) +
3171  (capList->Descriptors[i].BlockLength[2]);
3172 
3173  // Given the {NumberOfBlocks, BlockLength} from this Capacity List
3174  // Descriptor, find a matching entry in FloppyCapacities[].
3175  //
3176  for (j = 0; j < FLOPPY_CAPACITIES; j++)
3177  {
3178  if (NumberOfBlocks == FloppyCapacities[j].NumberOfBlocks &&
3179  BlockLength == FloppyCapacities[j].BlockLength)
3180  {
3181  // A matching capacity was found, record it.
3182  //
3183  capacityMatches[j] = TRUE;
3184 
3185  // A match was found for the first Capacity List
3186  // Descriptor returned by the device.
3187  //
3188  if (i == 0)
3189  {
3190  currentGeometry = j;
3191  }
3192  } else if ((capList->Descriptors[i].Valid) &&
3193  (BlockLength == FloppyCapacities[j].BlockLength)) {
3194 
3195  ULONG inx;
3196  ULONG mediaInx;
3197 
3198  //
3199  // Check if this is 32MB media type. 32MB media
3200  // reports variable NumberOfBlocks. So we cannot
3201  // use that to determine the drive type
3202  //
3204  if (inx != DRIVE_TYPE_NONE) {
3205  mediaInx = DriveMediaLimits[inx].HighestDriveMediaType;
3206  if ((DriveMediaConstants[mediaInx].MediaType)
3207  == F3_32M_512) {
3208  capacityMatches[j] = TRUE;
3209 
3210  if (i == 0) {
3211  currentGeometry = j;
3212  }
3213  }
3214  }
3215  }
3216  }
3217  }
3218 
3219  // Default status is STATUS_UNRECOGNIZED_MEDIA, unless we return
3220  // either STATUS_SUCCESS or STATUS_BUFFER_OVERFLOW.
3221  //
3223 
3224  if (ioControlCode == IOCTL_DISK_GET_DRIVE_GEOMETRY) {
3225 
3226  if (currentGeometry != -1)
3227  {
3228  // Update the current device geometry
3229  //
3230  fdoExtension->DiskGeometry = FloppyGeometries[currentGeometry];
3231 
3232  //
3233  // Calculate sector to byte shift.
3234  //
3235 
3236  WHICH_BIT(fdoExtension->DiskGeometry.BytesPerSector,
3237  fdoExtension->SectorShift);
3238 
3239  fdoExtension->CommonExtension.PartitionLength.QuadPart =
3240  (LONGLONG)FloppyCapacities[currentGeometry].NumberOfBlocks *
3241  FloppyCapacities[currentGeometry].BlockLength;
3242 
3243  DebugPrint((2,"geometry is: %3d %2d %d %2d %4d %2d %08X\n",
3244  fdoExtension->DiskGeometry.Cylinders.LowPart,
3245  fdoExtension->DiskGeometry.MediaType,
3246  fdoExtension->DiskGeometry.TracksPerCylinder,
3247  fdoExtension->DiskGeometry.SectorsPerTrack,
3248  fdoExtension->DiskGeometry.BytesPerSector,
3249  fdoExtension->SectorShift,
3250  fdoExtension->CommonExtension.PartitionLength.LowPart));
3251 
3252  // Return the current device geometry
3253  //
3254  if (Irp != NULL)
3255  {
3256  *outputBuffer = FloppyGeometries[currentGeometry];
3257 
3258  Irp->IoStatus.Information = sizeof(DISK_GEOMETRY);
3259  }
3260 
3262  }
3263 
3264  } else {
3265 
3266  // Iterate over the capacities and return the geometry
3267  // corresponding to each matching Capacity List Descriptor
3268  // returned from the device.
3269  //
3270  // The resulting list should be in sorted ascending order,
3271  // assuming that the FloppyGeometries[] array is in sorted
3272  // ascending order.
3273  //
3274  for (i = 0; i < FLOPPY_CAPACITIES; i++)
3275  {
3276  if (capacityMatches[i] && FloppyCapacities[i].CanFormat)
3277  {
3278  if (outputBuffer < outputBufferEnd)
3279  {
3280  *outputBuffer++ = FloppyGeometries[i];
3281 
3282  Irp->IoStatus.Information += sizeof(DISK_GEOMETRY);
3283 
3284  DebugPrint((2,"geometry : %3d %2d %d %2d %4d\n",
3285  FloppyGeometries[i].Cylinders.LowPart,
3290 
3292  }
3293  else
3294  {
3295  // We ran out of output buffer room before we ran out
3296  // geometries to return.
3297  //
3299  }
3300  }
3301  }
3302  }
3303  }
3304  else if (NT_SUCCESS(status))
3305  {
3306  // The SCSIOP_READ_FORMATTED_CAPACITY request was successful, but
3307  // returned data does not appear valid.
3308  //
3310  }
3311 
3312  ExFreePool(dataBuffer);
3313  ExFreePool(srb);
3314 
3315  return status;
3316 }
DRIVE_MEDIA_CONSTANTS DriveMediaConstants[]
Definition: floppy.c:173
#define TRUE
Definition: types.h:120
#define FLOPPY_CAPACITIES
Definition: floppy.c:292
FORMATTED_CAPACITY FloppyCapacities[]
Definition: floppy.c:249
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
UCHAR Cdb[16]
Definition: srb.h:271
DISK_GEOMETRY DiskGeometry
Definition: classpnp.h:704
_In_ PIRP Irp
Definition: csq.h:116
GLuint GLuint GLsizei count
Definition: gl.h:1545
DRIVE_MEDIA_LIMITS DriveMediaLimits[NUMBER_OF_DRIVE_TYPES]
Definition: floppy.c:136
ULONG DataTransferLength
Definition: srb.h:253
LONG NTSTATUS
Definition: precomp.h:26
COMMON_DEVICE_EXTENSION CommonExtension
Definition: classpnp.h:695
UCHAR CdbLength
Definition: srb.h:250
ULONG BytesPerSector
Definition: ntdddisk.h:376
ULONG TracksPerCylinder
Definition: ntdddisk.h:374
ULONG TimeOutValue
Definition: srb.h:254
UCHAR SrbStatus
Definition: srb.h:243
#define SRB_STATUS(Status)
Definition: srb.h:381
#define WHICH_BIT(Data, Bit)
Definition: tools.h:80
#define PAGED_CODE()
Definition: video.h:57
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:64
#define STATUS_UNRECOGNIZED_MEDIA
Definition: udferr_usr.h:142
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
NTSTATUS NTAPI ClassSendSrbSynchronous(PDEVICE_OBJECT Fdo, PSCSI_REQUEST_BLOCK Srb, PVOID BufferAddress, ULONG BufferLength, BOOLEAN WriteToDevice)
Definition: class.c:2648
long LONG
Definition: pedump.c:60
DRIVE_MEDIA_TYPE HighestDriveMediaType
Definition: floppy.c:121
PVOID DeviceExtension
Definition: env_spec_w32.h:418
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
#define SCSIOP_READ_FORMATTED_CAPACITY
Definition: scsi.h:272
struct _FORMATTED_CAPACITY_LIST * PFORMATTED_CAPACITY_LIST
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
int64_t LONGLONG
Definition: typedefs.h:66
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
LARGE_INTEGER Cylinders
Definition: ntdddisk.h:372
ULONG SectorsPerTrack
Definition: ntdddisk.h:375
MEDIA_TYPE MediaType
Definition: ntdddisk.h:373
#define SRB_STATUS_DATA_OVERRUN
Definition: srb.h:349
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
unsigned char UCHAR
Definition: xmlstorage.h:181
struct _DISK_GEOMETRY * PDISK_GEOMETRY
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
ULONG LowPart
Definition: typedefs.h:104
ULONG NTAPI DebugPrint(IN PSTRING DebugString, IN ULONG ComponentId, IN ULONG Level)
Definition: debug.c:23
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2745
struct _DISK_GEOMETRY DISK_GEOMETRY
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:61
struct _FORMATTED_CAPACITY_LIST FORMATTED_CAPACITY_LIST
ULONG DetermineDriveType(PDEVICE_OBJECT DeviceObject)
Definition: floppy.c:1913
#define SCSI_REQUEST_BLOCK_SIZE
Definition: srb.h:274
NTSTATUS NTAPI ClassReadDriveCapacity(IN PDEVICE_OBJECT Fdo)
Definition: class.c:1729
DISK_GEOMETRY FloppyGeometries[]
Definition: floppy.c:264
struct _FORMATTED_CAPACITY_DESCRIPTOR FORMATTED_CAPACITY_DESCRIPTOR
#define DRIVE_TYPE_NONE
Definition: floppy.c:61
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2772
return STATUS_SUCCESS
Definition: btrfs.c:2966
static SERVICE_STATUS status
Definition: service.c:31
FORMATTED_CAPACITY_DESCRIPTOR Descriptors[0]
Definition: scsi.h:1804
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define IOCTL_DISK_GET_DRIVE_GEOMETRY
Definition: cdrw_usr.h:169
Definition: ps.c:97

Referenced by ScsiFlopDeviceControl().

Variable Documentation

◆ DriveMediaConstants

◆ DriveMediaLimits

◆ DriverEntry

DRIVER_INITIALIZE DriverEntry

Definition at line 341 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}
}
#define TRUE
Definition: types.h:120

Definition at line 249 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}
}
#define F3_1Pt2_512
Definition: vfdfmt.c:27
#define F3_640_512
Definition: vfdfmt.c:24

Definition at line 264 of file floppy.c.

Referenced by USBFlopFormatTracks(), and USBFlopGetMediaTypes().

◆ ScsiFlopAddDevice

DRIVER_ADD_DEVICE ScsiFlopAddDevice

Definition at line 345 of file floppy.c.

Referenced by DriverEntry().

◆ ScsiFlopUnload

DRIVER_UNLOAD ScsiFlopUnload

Definition at line 343 of file floppy.c.

Referenced by DriverEntry().