Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
NT4/private/ntos/dd/floppy/floppy.c

9192 lines
281 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
floppy.c
Abstract:
This is the NEC PD756 (aka AT, aka ISA, aka ix86) and Intel 82077
(aka MIPS) floppy diskette driver for NT.
Author:
Chad Schwitters (chads) 14-Jul-1991.
Environment:
Kernel mode only.
Revision History:
02-Aug-1991 (chads) Made driver work on MIPS as well as ix86.
#if defined(DBCS) && defined(_MIPS_)
N001 1994.07.29 N.Johno
- Modify for R96(MIPS/R4400)
#endif // defined(DBCS) && defined(_MIPS_)
Notes:
The NEC PD765 is the controller standard used on almost all ISA PCs
(Industry Standard Architecture, which use Intel x86 processors).
More advanced controllers like the Intel 82077 (which is used on
many MIPS machines) are supersets of the PD765 standard.
Overview of this driver:
This driver must deal with floppy drives, and the media that may
or may not be in them. "Drive" and "controller" refer to the
hardware connected to the machine, and "media" or "diskette"
refers to the floppy that gets inserted into the drive.
Communicating with the controller can involve a lot of delays,
so this driver creates a thread to talk to the controller (since
we can't wait in another thread's context). The initialization
and dispatch routines are executed in the context of the caller,
and the ISR and DPC routines could be anywhere, but everything
else is executed in the context of the thread. The dispatch
routines put requests into an interlocked queue and signal the
thread; the thread wakes up and processes the requests serially.
A big advantage of the thread approach is that synchronization
problems are almost non-existent. Interrupts always come when
the floppy is blocked and waiting for them (well, there could be
a spurious interrupt, but the ISR won't do anything critical in
that event), so the only opening for contention is with the DPC
that turns off the drive motor. A spin lock is used to keep the
thread and the DPC from trying to access variables or registers
at the same time.
Data structures include a controller extension that holds all
variables common to the controller, a device extension that
holds all variables common to the drive, and a read-only table
that holds parameters used for communicating with the controller
given a drive/media combination. The data structures will be
described in more detail later.
Since this driver deals with removable media, it must do its
share of volume tracking. Before processing any packet, it must
check some flags - if the volume needs to be verified, the
packet must be returned with STATUS_VERIFY_REQUIRED. Then, the
disk's changeline must be checked. If it is set, it should be
reset, and the packet should be returned with
STATUS_VERIFY_REQUIRED. (If it can't be reset, then the packet
should be failed with STATUS_NO_MEDIA_IN_DEVICE).
Before any operation, the motor timer must be cancelled, the
drive must be selected, its motor must be turned on and given a
chance to spin up, the changeline must be checked (and possibly
dealt with as mentioned above), write access (if requested) must
be checked, and the media type must be determined.
Determining the media type is an unusual process. The drive
type is obtained from the configuration manager at
initialization time. Any time that the changeline is set (which
includes startup) the media type is unknown, and must be
determined. The DriveMediaLimits table is used to determine
which drive/media combinations are allowable, and the driver
assumes that the media with the largest capacity is in the
drive. It sets up the controller to read that media, and tries
to read an ID mark from the disk. As long as that fails, it
tries a lower media type. If no media type works, an error is
returned. If one works, it is assumed to properly indicate the
media in the drive, but it could be wrong because some
drive/media combinations use the same controller parameters. So
whenever we find that the first sector on the disk is being read
(which should be the first thing the file system does for a new
disk; this will work even if the media type assumption is wrong)
we sneak a peek at the media descriptor byte and change our
assumption about the media type if necessary.
An operation passed in by the system is called a "request".
This driver often breaks the request into smaller pieces called
"transfers" because of limitations in the amount of data that
can be read or written at one time.
Background on hardware operation:
The following info was gathered from a number of technical
reference documents and existing device drivers. These sources
often did not agree; where there was a problem, I tried to
determine the answer by consensus or experimentation.
At initialization, the following steps should be performed:
reset the controller
wait for an interrupt
for each diskette
issue SENSE INTERRUPT STATUS command
optionally issue the CONFIGURE command
issue SPECIFY command
program the data rate
The data rate, CONFIGURE and SPECIFY information should be
reprogrammed after every reset.
To do a SEEK or RECALIBRATE, the motor should be turned on and
the command should be issued. After the interrupt comes, a
SENSE INTERRUPT STATUS command should be issued.
To do a READ or WRITE, the motor should be turned on, and left
to spin up for at least 500ms. The recorded data rate of the
inserted media can then be determined by performing a READ ID at
each data rate until a successful status is returned. Then
there should be a seek, followed by at least a 15ms head
settling time. DMA is set up, and the command is issued. When
the data has been transferred, the controller will interrupt.
If an error is encountered, two more retries should be performed
by reinitializing the DMA and re-issuing the command. If that
fails, the disk should be recalibrated and the seek repeated for
two more tries.
The following registers can be used to program the floppy
controller. Each is discussed in detail below:
AT JAZZ Read/ Register Name
Address Address Write (for this driver)
3f2 write DriveControl
3f4 read Status
3f5 both Fifo
3f7 write DataRate
3f7 read DiskChange
Notes on other register usages:
3f0 is used by the Intel chip, but only for PS/2s.
3f1 is readable on Compaqs, and called "media id". The
Intel chip only uses 3f1 on PS/2s.
3f2 is readable on the Intel chip.
3f3 doesn't appear to be used by anybody.
3f4 is writable and called "data rate select" on the Intel
chip.
3f6 is used for fixed disk operations.
3f7 does not seem to be mentioned by one [old] reference,
but all the others do - and it seems to be essential, so I'm
going to use it.
DriveControl (aka "digital output", aka "floppy operations"):
bits 0-1: drive select (values 10 and 11 not always used)
bit 2: 0 = reset controller, 1 = enable controller
bit 3: 0 = interrupts and DMA disabled, 1 = enabled
bit 4: 0 = drive 1 motor off, 1 = on
bit 5: 0 = drive 2 motor off, 1 = on
bit 6: 0 = drive 3 motor off, 1 = on (not always used)
bit 7: 0 = drive 4 motor off, 1 = on (not always used)
Note that a drive cannot be selected unless its motor is on
(setting the bits at the same time is acceptable).
Status:
bit 0: drive 0 busy (seeking or recalibrating)
bit 1: drive 1 busy
bit 2: drive 2 busy (not always used)
bit 3: drive 3 busy (not always used)
bit 4: controller busy (from command byte until result phase)
bit 5: DMA is not being used
bit 6: 0 = data from processor to controller, 1 = reverse
bit 7: 1 = data ready to be transferred
Note that command bytes can't be written to the DATA
register unless bit 7 is 1 and bit 6 is 0. Similarly,
result bytes can't be read from the DATA register unless bit
7 is 1 and bit 6 is 1. The delay for this to become true
could be 175us on the Intel chip; older chips may take
longer.
Fifo (aka "data"):
All commands are written here one byte at a time, and all
results are similarly read from here. Commands and results
are discussed below.
Some controllers have a buffer and programmable threshold,
which allows the data to be sent in chunks rather than one
byte at a time. This reduces the chance of an overrun.
After some commands, the values of status registers (and
other things) are returned through the Fifo register.
Here's the layout of the status registers:
Status Register 0:
bits 0-1: drive number
bit 2: head
bit 3: set if drive is not ready
bit 4: set if drive faults, or recalibrate didn't find
track 0
bit 5: set when seek is completed
bits 6-7: 00 = normal termination
01 = abnormal termination, error
10 = invalid command
11 = abnormal termination, drive became not ready
Status Register 1:
bit 0: set if the ID address mark wasn't found
bit 1: set if write-protection detected during a write
bit 2: set if sector not found
bit 3: always 0
bit 4: set for data overrun
bit 5: set if CRC error detected in ID or data
bit 6: always 0
bit 7: set on attempt to access a sector beyond the end of a
cylinder
Status Register 2:
bit 0: set if data address or deleted data mark not found
bit 1: set if bad cylinder found
bit 2: set if SCAN fails to find sector meeting condition
bit 3: set if SCAN command meets "equal" condition
bit 4: set if wrong cylinder found
bit 5: set if CRC error detected in data
bit 6: set if deleted address data mark encountered during
READ or SCAN
bit 7: always 0
Status Register 3:
bits 0-1: drive number
bit 2: head
bit 3: set if drive is two-sided
bit 4: set if drive is on track 0
bit 5: set if the drive is ready
bit 6: set if the drive is write-protected
bit 7: set if the drive has faulted
DataRate (aka "configuration control"):
bits 0-1: 00 = 500 kb/s, 01 = 300, 10 = 250, 11 = 1 Mb/s for
3.5" and 125 kb/s for 5.25"
bits 2-7: reserved, 0
DiskChange (aka "digital input", aka "diskette status"):
bits 0-6: reserved (often used for fixed disks)
bit 7: 1 = previous diskette has been removed
Common Commands:
Each command and its parameters are given to the controller
through the Data register. The controller then executes the
command. When finished, the results can be read from the
controller through the Data register.
A drive's motor must be on before the drive can be
selected. Units 0 and 1 cannot have their motor on
simultaneously; neither can units 2 and 3.
A drive cannot be accessed until <head load time> has passed
since selecting the drive.
A drive cannot be accessed until <head settle time> has
passed since an earlier access.
Fields used in commands:
Multi-Track: if this bit is set, both tracks of the
cylinder will be operated on.
MFM/FM Mode: if this bit is set, MFM mode (double
density) is selected if it's implemented; if not, FM
mode (single density) is selected.
Skip: when this bit is set, sectors with a deleted data
address mark will be skipped for READ DATA or accessed
for READ DELETED DATA.
Head: one bit, 0 or 1.
Drive Select: two bits to select drive 0 through 3.
Cylinder: 7 bits selecting the cylinder.
Sector: 4 bits giving the number of the first sector to
be accessed.
Sector Size Code: the sector size is 2^(this value) *
128. Sometimes forced to be 2, for 512-byte sectors.
Final Sector of Track: 4 bits giving the final sector
number of current track.
Gap Length: 8 bits giving the size of the gap between
sectors excluding the VC0 synchronization field.
Data Length: if Sector Size Code is 0, the sector size
is 128 but this value says how many bytes are actually
transferred (extra bytes dropped on READs, extra bytes
zeroed on WRITEs). If Sector Size code is not 0
(sometimes it's forced nonzero), this value should be
0xff.
Sectors per Track: 4 bits giving the number of sectors
per cylinder to be initialized by a FORMAT.
Data Pattern: 8 bits giving the pattern to be written in
each sector data field during a FORMAT.
Step Rate Interval: 4 bits. The time between step
pulses. From .5 to 8ms in .5ms increments at 1Mb data
rate. See the SPECIFY command.
Head Unload Time: 4 bits. The time from the end of a
read or write until the head is unloaded. 0 to 480ms in
32ms increments. See the SPECIFY command.
Head Load Time: 7 bits. The time from loading the head
until starting the read or write operation. 4 to 512ms
in 4ms increments. See the SPECIFY command.
Non-DMA Mode Flag: 0 = DMA mode, 1 = host is interrupted
for each data transfer.
New Cylinder Number: 7 bits giving the desired cylinder
number.
The commands are given below. For each commands, the bytes
that must be written to the controller are listed. When the
command is finished (after an interrupt for most commands)
the further listed bytes MUST be read from the controller.
READ DATA - move sector from diskette to memory via DMA.
Heads are automatically loaded and unloaded.
WRITE Multi-Track, MFM/FM Mode, Skip, 00110
WRITE 00000, Head, Drive Select
WRITE Cylinder
WRITE Head
WRITE Sector
WRITE Sector Size Code
WRITE Final Sector of Track
WRITE Gap Length
WRITE Data Length
<interrupt>
READ Status Register 0
READ Status Register 1
READ Status Register 2
READ Cylinder
READ Head
READ Sector
READ Sector Size Code
READ DELETED DATA - same as READ DATA, but only sectors with
the deleted data address mark are read.
WRITE Multi-Track, MFM/FM Mode, Skip, 01100
WRITE 00000, Head, Drive Select
WRITE Cylinder
WRITE Head
WRITE Sector
WRITE Sector Size Code
WRITE Final Sector of Track
WRITE Gap Length
WRITE Data Length
<interrupt>
READ Status Register 0
READ Status Register 1
READ Status Register 2
READ Cylinder
READ Head
READ Sector
READ Sector Size Code
READ TRACK - same as READ DATA, but all sectors from the index
mark to the "end of track" sector are read.
WRITE 0, MFM/FM Mode, 000010
WRITE 00000, Head, Drive Select
WRITE Cylinder
WRITE Head
WRITE Sector
WRITE Sector Size Code
WRITE Final Sector of Track
WRITE Gap Length
WRITE Data Length
<interrupt>
READ Status Register 0
READ Status Register 1
READ Status Register 2
READ Cylinder
READ Head
READ Sector
READ Sector Size Code
WRITE DATA - move sector from memory to diskette via DMA.
Heads are automatically loaded and unloaded.
WRITE Multi-Track, MFM/FM Mode, 000101
WRITE 00000, Head, Drive Select
WRITE Cylinder
WRITE Head
WRITE Sector
WRITE Sector Size Code
WRITE Final Sector of Track
WRITE Gap Length
WRITE Data Length
<interrupt>
READ Status Register 0
READ Status Register 1
READ Status Register 2
READ Cylinder
READ Head
READ Sector
READ Sector Size Code
WRITE DELETED DATA - same as WRITE DATA, except a deleted
data address mark is written at the beginning of the data
field instead of the normal data address mark.
WRITE Multi-Track, MFM/FM Mode, 001001
WRITE 00000, Head, Drive Select
WRITE Cylinder
WRITE Head
WRITE Sector
WRITE Sector Size Code
WRITE Final Sector of Track
WRITE Gap Length
WRITE Data Length
<interrupt>
READ Status Register 0
READ Status Register 1
READ Status Register 2
READ Cylinder
READ Head
READ Sector
READ Sector Size Code
READ ID - the first ID field is read, and the status registers
are updated.
WRITE 0, MFM/FM Mode, 001010
WRITE 00000, Head, Drive Select
<interrupt>
READ Status Register 0
READ Status Register 1
READ Status Register 2
READ Cylinder
READ Head
READ Sector
READ Sector Size Code
FORMAT TRACK - the selected track is formatted from index to
"end of track" sector with address marks, ID fields, data
fields and field gaps. The data field is filled with the
specified pattern. The ID field data is specified by the host
*for each sector*.
The DMA must be set up to send four bytes for each sector to
be formatted. The bytes are Cylinder, Head, Sector, and Sector
Size Code.
WRITE 0, MFM/FM Mode, 001101
WRITE 00000, Head, Drive Select
WRITE Sector Size Code
WRITE Sectors per Track
WRITE Gap Length
WRITE Data Pattern
<interrupt>
READ Status Register 0
READ Status Register 1
READ Status Register 2
READ Undefined
READ Undefined
READ Undefined
READ Undefined
RECALIBRATE - the heads are stepped to track 0. But note
that some controllers give up before reaching track 0, so it
might be necessary to RECALIBRATE more than once. All
drives must be RECALIBRATEd at initialization time. There
are no result registers, so the ISR should issue a SENSE
INTERRUPT STATUS command - which will result in two result
registers.
WRITE 00000111
WRITE 000000, Drive Select
<interrupt>
SENSE INTERRUPT STATUS - the interrupt level is cleared, and
the controller status is returned.
WRITE 00001000
READ Status Register 0
READ Cylinder
SPECIFY - the head load and unload rates, the drive step rate,
and the DMA data transfer mode are set.
WRITE 00000011
WRITE Step Rate Interval, Head Unload Time
WRITE Head Load Time, Non-DMA Mode Flag
SENSE DRIVE STATUS - the status of the selected drive is
returned.
WRITE 00000100
WRITE 00000, Head, Drive Select
READ Status Register 3
SEEK - the selected drive is stepped to the new cylinder.
Seeks generally must be explicit, but on some controllers
can be made implicit via the CONFIGURE command. When not
implicit, READs and WRITEs should be preceded by SEEK, SENSE
INTERRUPT STATUS, and READ ID. There are no result
registers, so the ISR should issue a SENSE INTERRUPT STATUS
command - which does have two result registers.
WRITE 00001111
WRITE 00000, Head, Drive Select
WRITE New Cylinder Number
<interrupt>
Commands not always implemented:
Any command not implemented by a controller will result in
Status Register 0 returning x80 - "invalid command".
The following commands are implemented by some controllers,
but not by all of the ones studied:
Scan Equal
Scan Low or Equal
Scan High or Equal
Verify
Version
Configure
Relative Seek
Dump Registers
Perpendicular Mode
Data structures:
For each floppy controller in the system (there's seldom more
than one) a controller data area is allocated. This area holds
all information about the controller, and all information common
to all of the drives attached to it. It has the following
fields:
FifoBuffer[10] - data is sent to and received from the
controller via a FIFO port. A single routine,
FlIssueCommand(), is used to send the command and
parameters, and receive the result bytes. Before calling
FlIssueCommand(), the parameters should be placed into the
FifoBuffer; and after the command, the result bytes can be
read from the buffer. Note that for commands with a result
phase, the first result byte is read into the buffer by the
ISR. For commands without a result phase, the ISR writes a
SENSE INTERRUPT STATUS command, which means that *that*
command's result bytes will have to be read by
FlIssueCommand().
InterruptDelay - set to a few seconds. When we're waiting
for an interrupt, we use this as a time-out value.
Minimum10msDelay - set to 10 milliseconds, which is the
smallest unit of time that the floppy thread can block. Used
when blocking to wait for the controller to become ready to
transfer bytes through the FIFO.
ListEntry - the list of requests for the floppy driver to
process. The dispatch routines add requests to the tail of
the list, and the floppy thread takes them off at the head.
In some cases of hardware failure, the floppy thread will
reinsert a request at the head of the list to try the packet
again.
InterruptEvent - the event that is waited on when we're
expecting the controller to interrupt. It should be reset
before programming the controller, and set in the DPC that
is queued by the ISR.
AllocateAdapterChannelEvent - the event that is waited on
when we're allocating a DMA adapter channel. It should be
reset before requesting the adapter, and set by the DPC that
is queued by the IO system when the adapter channel is
available.
RequestSemaphore - the semaphore that the floppy thread waits
on. It should be released by the dispatch routines whenever
they add a request to the list. Note that it can also be
released when the thread is supposed to terminate
ListSpinLock - a spinlock that is allocated and used when
manipulating the list of requests for the floppy thread in
an atomic fashion (via the ExInterlocked* routines).
InterruptObject - a pointer to an interrupt object; it must
be passed to IoConnectInterrupt.
MapRegisterBase - the base address of the map registers.
Whenever an adapter channel is allocated, this value is passed
to our DPC. It's stored in the controller object so it can
be used when we call IoMapTransfer() and
IoFlushAdapterBuffers().
IoBuffer - this driver always needs to allocate at least a
page to format floppies. On systems where there might not
be enough map registers to map the largest possible transfer
(the size of the largest supported track on the system), a
contiguous buffer of that size is allocated. Transfers for
which there aren't enough map registers are copied to or from
this buffer, since it is contiguous.
IoBufferMdl - an MDL (memory descriptor list) to describe
"IoBuffer". Used to lock the pages, flush the buffer, etc.
AdapterObject - an object obtained from HalGetAdapter() that
must be used when allocating a DMA adapter channel.
CurrentDeviceObject - set to the device object in question
whenever an interrupt is expected. This aids debugging and
lets the ISR know whether an interrupt was expected or not.
DriverObject - We keep a pointer around to the driver object
so that we can log an error if the controller object. The reason
we don't use the CurrentDeviceObject is that we may not have one
when we get around to logging the error.
ControllerAddress - the virtual or I/O space address of the
base of the floppy controller, which is obtained from
configuration management.
IoBufferSize - the size of "IoBuffer"; it is either a single
page (if there's plenty of map registers) or the size of the
largest track supported by the drives in the system.
IsrReentered - This is counter that is used to determine
if we are in a hang condition from the controller on a
level sensitive machine.
SpanOfControllerAddress - Indicates the number of bytes
used by the controllers register set. This is only useful
when the device is being unloaded and the controller address
is being unmapped.
LastDriveMediaType - every time FlDatarateSpecifyConfigure()
is called, this value is set to the DriveMediaType that it
configured the controller to handle. When FlStartDrive() is
preparing an operation, it checks to see if the current
drive/media combination is the same - if not,
FlDatarateSpecifyConfigure() must be called again.
NumberOfMapRegisters - the number of map registers available
to this driver, obtained from HalGetAdapter(), and possibly
lowered to the maximum number needed. Each register allows
the driver to map a single page (or more if the pages are
contiguous, but that's only counted on when the driver
allocated the contiguous buffer itself). This value is used
to determine whether or not the driver needs to allocate a
contiguous buffer to accomodate a transfer the size of the
largest track, and it is passed to IoAllocateAdapterChannel().
NumberOfDrives - the number of drives attached to this
controller, obtained from the configuration manager. This
is used when allocating device objects and resetting the
hardware.
DriveControlImage - the image of the drive control register.
We must keep track of it since the register is read-only on
some systems. It should always be updated before writing to
the drive control register.
ControllerConfigurable - indicates whether or not the
CONFIGURE command is available. Assumed to be TRUE, it's
set to FALSE if an attempt to issue the CONFIGURE command
fails. Controllers with the CONFIGURE command are configured
to SEEK implicitly.
HardwareFailCount - this is only used in FlFinishOperation.
If an operation fails due to a hardware problem, we'll retry
a certain number of times, and this keeps track of how many
times we've retried.
HardwareFailed - this Boolean is set to FALSE at
initialization time and when each packet starts (even if
it's a retry). Whenever a hardware problem is encountered,
it is set to TRUE. At initialization time, failure to
initialize the hardware on the first drive means we must try
again on subsequent drives - if we never succeed, the driver
is unloaded. For each packet, hardware errors mean we'll
reset the hardware and retry the packet until it succeeds or
we overrun HardwareFailCount.
CommandHasResultPhase - whenever a command is issued,
FlIssueCommand() sets this to TRUE if the command will
return result bytes. FloppyInterruptService() uses this to
decide how to dismiss the interrupt. Note that the BUSY bit
in the STATUS register should give us this information, but
it's sometimes set when it shouldn't be.
MappedControllerAddress - Set to TRUE indicates that when
unloading the driver, the pointer to the device controller
base register should be unmapped.
For each physical floppy drive, a device object is allocated so
that the I/O system can access the drive. Attached to each device
object is a diskette extension structure, which contains
information specific to the drive and the media in it. Each
diskette extension contains a pointer to the controller data area
for the controller that it's attached to. Fields in the structure:
DeviceObject - a pointer to the device object to which this
diskette extension is appended.
ControllerData - a pointer to the controller data area that
describes the controller this drive is attached to.
DriveType - the type of the physical drive, as defined in
flo_data.h.
BytesPerSector - the bytes per sector of the media that was
last identified in the drive. Used to validate access
requests in the dispatch routines.
ByteCapacity - the total number of bytes on the media that
was last identified in the drive. Used to validate access
requests in the dispatch routines.
MediaType - the last type of media identified in the drive
(or "Unknown") as defined in ntdddisk.h. This value is used
to determine whether other media values in the diskette
extension are valid, and whether or not
FlDetermineMediaType() needs to be called.
DriveMediaType - the last drive/media combination value,
determined when the media in the drive was last identified.
This is used to index into the DriveMediaConstants table.
DeviceUnit - the controller-relative diskette number, which
is needed for some controller commands.
DriveOnValue - the value that must be written to the
Drive Control register to start up the drive in question.
It's the "DeviceUnit" plus a few bits.
The DriveMediaLimits table, which is read-only, tells the driver
which drive/media combinations are valid for a drive type. The
table is indexed by the drive type, and has LowestDriveMediaType
and HighestDriveMediaType fields. The drive/media types are
enumerated in ascending order, so the driver can start at the
highest possible combination and decrement the value until the
correct one is found (or it goes below the lowest valid
drive/media combination).
The DriveMediaConstants table, which is read-only, tells the driver
values that it needs to use when communicating with the controller
given the drive and media type. The table is indexed by the
DriveMedia number (unique for each drive/media combination) and
has the following fields:
MediaType - the type of media specified by this drive/media
combination. The drive type is stored in the diskette
extension, since it never changes.
StepRateHeadUnloadTime - a combination value that is written
to the controller as part of the SPECIFY command. The step
rate is how fast the heads can be moved track-to-track, and
the head unload time is how long it takes for the heads to
be unloaded after a READ or WRITE.
HeadLoadTime - a value that is written to the controller as
part of the SPECIFY command. The head load time is how long
it takes the heads to stabilize after a SEEK before a READ
or WRITE can be initiated.
MotorOffTime - not used by this driver, but included to keep
the table complete.
SectorLengthCode - a code number that specifies the sector
size. The sector size is 2 to the "code" power, times 128.
So 0 means 128 bytes, 1 means 256, 2 means 512, etc. This
number is needed to pass to the controller for several
commands.
BytesPerSector - the bytes per sector, which can be
determined from SectorLengthCode. Included as a separate
field for simplicity and speed.
SectorsPerTrack - the number of sectors on a track (one head
of a cylinder).
ReadWriteGapLength - the space between sectors, not
including the synchronization field. Used for READ and
WRITE commands.
FormatGapLength - gap length passed to the FORMAT command.
FormatFillCharacter - passed to the FORMAT command; this
byte will be used to fill the data fields on the disk.
HeadSettleTime - the amount of time, in milliseconds, that
the driver must wait after performing a seek.
MotorSettleTimeRead - the amount of time, in milliseconds,
that the driver must wait for the drive to spin up before
performing a READ.
MotorSettleTimeWrite - the amount of time, in milliseconds,
that the driver must wait for the drive to spin up before
performing a WRITE. Note that WRITEs are more picky about
stable rotation speeds, so the drive must always spin up for
a longer than it would for a READ.
MaximumTrack - the number of the highest track, or cylinder
on disk (zero-based).
CylinderShift - normally 0, so it does nothing. This field
is used as a shift for the cylinder number before a SEEK
command. This is because of a hardware bug; 1.2Mb drives
don't seek the proper distance for low-density media, so for
those drive/media combinations this value is 1.
DataTransferRate - the number written to the Datarate
register before accessing the media.
NumberOfHeads - number of heads on the media, always 1 or 2
for floppies.
DataLength - always 0xff, this value must be given to the
controller for a READ or WRITE command.
The CommandTable, which is read-only, tells the driver how many
bytes it has to send and receive when issuing a command to the
controller. It is indexed by the command itself (minus any extra
bits, like COMMND_MFM) and has the following fields:
NumberOfParameters - the number of parameter bytes that must
be sent along with this command.
FirstResultByte - if the command has a result phase, then the
ISR reads the first byte so this value is 1 (meaning that the
0th byte has already been read). If there is no result phase,
then the ISR must give a SENSE INTERRUPT STATUS command, and
this value is 0.
NumberOfResultBytes - the number of bytes that must be read
from the controller after this command. For commands with
a result phase, this is the number of bytes returned minus
one (which was read by the ISR); for commands without a result
phase, this is "2" since that many bytes are returned by the
SENSE INTERRUPT STATUS command that is issued by the ISR.
InterruptExpected - a Boolean that indicates whether or not
this command will give an interrupt.
AlwaysImplemented - a Boolean that indicates whether or not
this command will always work. The CONFIGURE command, for
example, is useful but not always available. This helps to
determine the correct course of action when the controller
returns an error.
Hardware quirks:
Many controllers will only step 77 tracks on a recalibrate
command. But many drives have more tracks than that, so two
recalibrates are sometimes needed.
When a 40-track diskette is in a 1.2Mb drive, the cylinder
number must be *doubled* before seeking. The number returned by
the seek will be the fake number, but the number returned by a
READ ID will be the correct cylinder. This makes implied SEEKs
impossible on low-density 5.25" media.
Some machines will give an unexpected interrupt during a
controller reset unless bit 2 of the drive control register is
set in BOTH of the bytes that are written to the register.
On fast machines, the BUSY bit is sometimes set in the main
status register even though the command doesn't have a result
phase and the command is obviously finished (as evidenced by the
fact that it interrupted; the ISR is where this problem shows
up).
On at least the NCR 8 processor machine, we have seen the driver's
system thread run before the floppy controller can start the
SENSE_INTERRUPT command. We have placed code in the ISR to spin
until the SENSE command starts. (Actually it will time
out after ISR_SENSE_RETRY_COUNT 1 microsecond stalls.)
--*/
//
// Include files.
//
#include "ntddk.h" // various NT definitions
#include "ntdddisk.h" // disk device driver I/O control codes
#include <flo_data.h> // this driver's data declarations
//
// This is the actual definition of FloppyDebugLevel.
// Note that it is only defined if this is a "debug"
// build.
//
#if DBG
extern ULONG FloppyDebugLevel = 0;
#endif
#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT,DriverEntry)
#pragma alloc_text(INIT,FlConfigCallBack)
#pragma alloc_text(INIT,FlGetConfigurationInformation)
#pragma alloc_text(INIT,FlReportResources)
#pragma alloc_text(INIT,FlInitializeController)
#pragma alloc_text(INIT,FlInitializeDrive)
#pragma alloc_text(INIT,FlGetControllerBase)
#pragma alloc_text(PAGE,FlInitializeControllerHardware)
#pragma alloc_text(PAGE,FlSendByte)
#pragma alloc_text(PAGE,FlGetByte)
#pragma alloc_text(PAGE,FlInterpretError)
#pragma alloc_text(PAGE,FlIssueCommand)
#pragma alloc_text(PAGE,FlDatarateSpecifyConfigure)
#pragma alloc_text(PAGE,FlRecalibrateDrive)
#pragma alloc_text(PAGE,FlDetermineMediaType)
#pragma alloc_text(PAGE,FlCheckBootSector)
#pragma alloc_text(PAGE,FlConsolidateMediaTypeWithBootSector)
#pragma alloc_text(PAGE,FlReadWriteTrack)
#pragma alloc_text(PAGE,FlReadWrite)
#pragma alloc_text(PAGE,FlFormat)
#pragma alloc_text(PAGE,FlFinishOperation)
#pragma alloc_text(PAGE,FlStartDrive)
#pragma alloc_text(PAGE,FloppyThread)
#pragma alloc_text(PAGE,FlAllocateIoBuffer)
#pragma alloc_text(PAGE,FlTurnOnMotor)
#pragma alloc_text(PAGE,FlTurnOffMotor)
#pragma alloc_text(PAGE,FlFreeIoBuffer)
#pragma alloc_text(PAGE,FlDisketteRemoved)
#pragma alloc_text(PAGE,FloppyDispatchCreateClose)
#pragma alloc_text(PAGE,FloppyDispatchDeviceControl)
#pragma alloc_text(PAGE,FloppyDispatchReadWrite)
#pragma alloc_text(PAGE,FlCheckFormatParameters)
#endif
#ifdef POOL_TAGGING
#ifdef ExAllocatePool
#undef ExAllocatePool
#endif
#define ExAllocatePool(a,b) ExAllocatePoolWithTag(a,b,'polF')
#endif
// #define KEEP_COUNTERS 1
#ifdef KEEP_COUNTERS
ULONG FloppyUsedSeek = 0;
ULONG FloppyNoSeek = 0;
ULONG FloppyUsedBuffer = 0;
ULONG FloppyInterrupts = 0;
ULONG FloppySpurious = 0;
ULONG FloppyIntrBitSet = 0;
ULONG FloppyDPCs = 0;
ULONG FloppyThreadWake = 0;
LARGE_INTEGER FloppyIntrDelay = { 0, 0 };
LARGE_INTEGER FloppyDPCDelay = { 0, 0 };
LARGE_INTEGER FloppyThreadDelay = { 0, 0 };
LARGE_INTEGER FloppyFromIntrDelay = { 0, 0 };
LARGE_INTEGER FloppyThreadTime = { 0, 0 };
LARGE_INTEGER FloppyIntrTime = { 0, 0 };
LARGE_INTEGER FloppyEndIntrTime = { 0, 0 };
LARGE_INTEGER FloppyDPCTime = { 0, 0 };
#endif
//
// Used for paging the driver.
//
ULONG PagingReferenceCount = 0;
PFAST_MUTEX PagingMutex = NULL;
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This routine is the driver's entry point, called by the I/O system
to load the driver. This routine can be called any number of times,
as long as the IO system and the configuration manager conspire to
give it an unmanaged controller to support at each call. It could
also be called a single time and given all of the controllers at
once.
It initializes the passed-in driver object, calls the configuration
manager to learn about the devices that it is to support, and for
each controller to be supported it calls a routine to initialize the
controller (and all drives attached to it).
Arguments:
DriverObject - a pointer to the object that represents this device
driver.
Return Value:
If we successfully initialize at least one drive, STATUS_SUCCESS is
returned.
If we don't (because the configuration manager returns an error, or
the configuration manager says that there are no controllers or
drives to support, or no controllers or drives can be successfully
initialized), then the last error encountered is propogated.
--*/
{
PCONFIG_DATA configData; // pointer to config mgr's returned data
NTSTATUS ntStatus;
UCHAR controllerNumber;
BOOLEAN partlySuccessful = FALSE; // TRUE if any controller init'd properly
//
// We use this to query into the registry as to whether we
// should break at driver entry.
//
RTL_QUERY_REGISTRY_TABLE paramTable[3];
ULONG zero = 0;
ULONG one = 1;
ULONG debugLevel = 0;
ULONG shouldBreak = 0;
ULONG notConfigurable = 0;
ULONG model30 = 0;
PWCHAR path;
UNICODE_STRING parameters;
UNICODE_STRING systemPath;
UNICODE_STRING identifier;
UNICODE_STRING thinkpad, ps2e;
ULONG pathLength;
RtlInitUnicodeString(&parameters, L"\\Parameters");
RtlInitUnicodeString(&systemPath,
L"\\REGISTRY\\MACHINE\\HARDWARE\\DESCRIPTION\\System");
RtlInitUnicodeString(&thinkpad, L"IBM THINKPAD 750");
RtlInitUnicodeString(&ps2e, L"IBM PS2E");
pathLength = RegistryPath->Length + parameters.Length + sizeof(WCHAR);
if (pathLength < systemPath.Length + sizeof(WCHAR)) {
pathLength = systemPath.Length + sizeof(WCHAR);
}
//
// Since the registry path parameter is a "counted" UNICODE string, it
// might not be zero terminated. For a very short time allocate memory
// to hold the registry path zero terminated so that we can use it to
// delve into the registry.
//
// NOTE NOTE!!!! This is not an architected way of breaking into
// a driver. It happens to work for this driver because the author
// likes to do things this way.
//
if (path = ExAllocatePool(PagedPool, pathLength)) {
RtlZeroMemory(&paramTable[0],
sizeof(paramTable));
RtlZeroMemory(path, pathLength);
RtlMoveMemory(path,
RegistryPath->Buffer,
RegistryPath->Length);
paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
paramTable[0].Name = L"BreakOnEntry";
paramTable[0].EntryContext = &shouldBreak;
paramTable[0].DefaultType = REG_DWORD;
paramTable[0].DefaultData = &zero;
paramTable[0].DefaultLength = sizeof(ULONG);
paramTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
paramTable[1].Name = L"DebugLevel";
paramTable[1].EntryContext = &debugLevel;
paramTable[1].DefaultType = REG_DWORD;
paramTable[1].DefaultData = &zero;
paramTable[1].DefaultLength = sizeof(ULONG);
if (!NT_SUCCESS(RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
path,
&paramTable[0],
NULL,
NULL))) {
shouldBreak = 0;
debugLevel = 0;
}
//
// Determine whether or not this type of system has a
// model 30 floppy controller.
//
RtlZeroMemory(paramTable, sizeof(paramTable));
RtlZeroMemory(path, pathLength);
RtlMoveMemory(path,
systemPath.Buffer,
systemPath.Length);
RtlZeroMemory(&identifier, sizeof(UNICODE_STRING));
paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT |
RTL_QUERY_REGISTRY_REQUIRED;
paramTable[0].Name = L"Identifier";
paramTable[0].EntryContext = &identifier;
if (NT_SUCCESS(RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
path,
paramTable,
NULL,
NULL))) {
if (identifier.Length == thinkpad.Length &&
RtlCompareMemory(identifier.Buffer, thinkpad.Buffer,
thinkpad.Length) == thinkpad.Length) {
model30 = 1;
} else if (identifier.Length == ps2e.Length &&
RtlCompareMemory(identifier.Buffer, ps2e.Buffer,
ps2e.Length) == ps2e.Length) {
model30 = 1;
} else {
model30 = 0;
}
} else {
model30 = 0;
}
//
// This part gets from the parameters part of the registry
// to see if the controller configuration needs to be disabled.
// Doing this lets SMC 661, and 662 work. On hardware that
// works normally, this change will show a slowdown of up
// to 40%. So defining this variable is not recommended
// unless things don't work without it.
//
//
// Also check the model30 value in the parameters section
// that is used to override the decision above.
//
RtlZeroMemory(&paramTable[0],
sizeof(paramTable));
RtlZeroMemory(path,
RegistryPath->Length+parameters.Length+sizeof(WCHAR));
RtlMoveMemory(path,
RegistryPath->Buffer,
RegistryPath->Length);
RtlMoveMemory((PCHAR) path + RegistryPath->Length,
parameters.Buffer,
parameters.Length);
paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
paramTable[0].Name = L"NotConfigurable";
paramTable[0].EntryContext = &notConfigurable;
paramTable[0].DefaultType = REG_DWORD;
paramTable[0].DefaultData = &zero;
paramTable[0].DefaultLength = sizeof(ULONG);
paramTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
paramTable[1].Name = L"Model30";
paramTable[1].EntryContext = &model30;
paramTable[1].DefaultType = REG_DWORD;
paramTable[1].DefaultData = model30 ? &one : &zero;
paramTable[1].DefaultLength = sizeof(ULONG);
if (!NT_SUCCESS(RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
path,
&paramTable[0],
NULL,
NULL))) {
notConfigurable = 0;
}
}
//
// We don't need that path anymore.
//
if (path) {
ExFreePool(path);
}
#if DBG
FloppyDebugLevel = debugLevel;
#endif
if (shouldBreak) {
DbgBreakPoint();
}
FloppyDump(FLOPSHOW,
("Floppy: DriverEntry...\n"));
//
// Ask configuration manager for information on the hardware that
// we're supposed to support.
//
ntStatus = FlGetConfigurationInformation( &configData );
//
// If FlGetConfigurationInformation() failed, just exit and propogate
// the error. If it said that there are no controllers to support,
// return an error.
// Otherwise, try to init the controllers. If at least one succeeds,
// return STATUS_SUCCESS, otherwise return the last error.
//
if ( NT_SUCCESS( ntStatus ) ) {
//
// Call FlInitializeController() for each controller (and its
// attached drives) that we're supposed to support.
//
// Return success if we successfully initialize at least one
// device; propogate error otherwise. Set an error first in
// case there aren't any controllers.
//
ntStatus = STATUS_NO_SUCH_DEVICE;
for ( controllerNumber = 0;
controllerNumber < configData->NumberOfControllers;
controllerNumber++ ) {
ntStatus = FlInitializeController(configData,
controllerNumber,
DriverObject,
notConfigurable,
model30);
if ( NT_SUCCESS( ntStatus ) ) {
partlySuccessful = TRUE;
}
}
if ( partlySuccessful ) {
ntStatus = STATUS_SUCCESS;
//
// Initialize the driver object with this driver's entry points.
//
DriverObject->MajorFunction[IRP_MJ_CREATE] =
FloppyDispatchCreateClose;
DriverObject->MajorFunction[IRP_MJ_CLOSE] =
FloppyDispatchCreateClose;
DriverObject->MajorFunction[IRP_MJ_READ] = FloppyDispatchReadWrite;
DriverObject->MajorFunction[IRP_MJ_WRITE] = FloppyDispatchReadWrite;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] =
FloppyDispatchDeviceControl;
}
}
if ( !NT_SUCCESS( ntStatus ) ) {
FloppyDump(FLOPDBGP,
("Floppy: exiting with error %lx\n", ntStatus));
}
if (configData) {
ExFreePool(configData);
}
PagingMutex = ExAllocatePool(NonPagedPool, sizeof(FAST_MUTEX));
if (!PagingMutex) {
return STATUS_INSUFFICIENT_RESOURCES;
}
ExInitializeFastMutex(PagingMutex);
MmPageEntireDriver(DriverEntry);
return ntStatus;
}
NTSTATUS
FlConfigCallBack(
IN PVOID Context,
IN PUNICODE_STRING PathName,
IN INTERFACE_TYPE BusType,
IN ULONG BusNumber,
IN PKEY_VALUE_FULL_INFORMATION *BusInformation,
IN CONFIGURATION_TYPE ControllerType,
IN ULONG ControllerNumber,
IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation,
IN CONFIGURATION_TYPE PeripheralType,
IN ULONG PeripheralNumber,
IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation
)
/*++
Routine Description:
This routine is used to acquire all of the configuration
information for each floppy disk controller and the
peripheral driver attached to that controller.
Arguments:
Context - Pointer to the confuration information we are building
up.
PathName - unicode registry path. Not Used.
BusType - Internal, Isa, ...
BusNumber - Which bus if we are on a multibus system.
BusInformation - Configuration information about the bus. Not Used.
ControllerType - Should always be DiskController.
ControllerNumber - Which controller if there is more than one
controller in the system.
ControllerInformation - Array of pointers to the three pieces of
registry information.
PeripheralType - Should always be FloppyDiskPeripheral.
PeripheralNumber - Which floppy if this controller is maintaining
more than one.
PeripheralInformation - Arrya of pointers to the three pieces of
registry information.
Return Value:
STATUS_SUCCESS if everything went ok, or STATUS_INSUFFICIENT_RESOURCES
if it couldn't map the base csr or acquire the adapter object, or
all of the resource information couldn't be acquired.
--*/
{
//
// So we don't have to typecast the context.
//
PCONFIG_DATA config = Context;
//
// Simple iteration variable.
//
ULONG i;
//
// This boolean will be used to denote whether we've seen this
// controller before.
//
BOOLEAN newController;
//
// This will be used to denote whether we even have room
// for a new controller.
//
BOOLEAN outOfRoom;
//
// Iteration variable that will end up indexing to where
// the controller information should be placed.
//
ULONG ControllerSlot;
//
// Short hand for referencing the particular controller config
// information that we are building up.
//
PCONFIG_CONTROLLER_DATA controller;
PCM_FULL_RESOURCE_DESCRIPTOR peripheralData;
//
// These three boolean will tell us whether we got all the
// information that we needed.
//
BOOLEAN foundPort = FALSE;
BOOLEAN foundInterrupt = FALSE;
BOOLEAN foundDma = FALSE;
ASSERT(ControllerType == DiskController);
ASSERT(PeripheralType == FloppyDiskPeripheral);
//
// Check if the infprmation from the registry for this device
// is valid.
//
if (!(((PUCHAR)PeripheralInformation[IoQueryDeviceConfigurationData]) +
PeripheralInformation[IoQueryDeviceConfigurationData]->DataLength) ||
!(((PUCHAR)ControllerInformation[IoQueryDeviceConfigurationData]) +
ControllerInformation[IoQueryDeviceConfigurationData]->DataOffset)) {
ASSERT(FALSE);
return STATUS_INVALID_PARAMETER;
}
peripheralData = (PCM_FULL_RESOURCE_DESCRIPTOR)
(((PUCHAR)PeripheralInformation[IoQueryDeviceConfigurationData]) +
PeripheralInformation[IoQueryDeviceConfigurationData]->DataOffset);
//
// Loop through the "slots" that we have for a new controller.
// Determine if this is a controller that we've already seen,
// or a new controller.
//
outOfRoom = TRUE;
for (
ControllerSlot = 0;
ControllerSlot < MAXIMUM_CONTROLLERS_PER_MACHINE;
ControllerSlot++
) {
if (config->Controller[ControllerSlot].ActualControllerNumber == -1) {
newController = TRUE;
outOfRoom = FALSE;
config->Controller[ControllerSlot].ActualControllerNumber =
ControllerNumber;
config->NumberOfControllers++;
break;
} else if (config->Controller[ControllerSlot].ActualControllerNumber
== (LONG)ControllerNumber) {
newController = FALSE;
outOfRoom = FALSE;
break;
}
}
if (outOfRoom) {
//
// Just return and ignore the controller.
//
return STATUS_SUCCESS;
}
//
// Make sure we have room for this floppy disk peripheral.
//
if (config->Controller[ControllerSlot].NumberOfDrives >= MAXIMUM_DISKETTES_PER_CONTROLLER) {
return STATUS_SUCCESS;
}
controller = &config->Controller[ControllerSlot];
if (newController) {
PCM_FULL_RESOURCE_DESCRIPTOR controllerData =
(PCM_FULL_RESOURCE_DESCRIPTOR)
(((PUCHAR)ControllerInformation[IoQueryDeviceConfigurationData]) +
ControllerInformation[IoQueryDeviceConfigurationData]->DataOffset);
//
// We have the pointer. Save off the interface type and
// the busnumber for use when we call the Hal and the
// Io System.
//
controller->InterfaceType = BusType;
controller->BusNumber = BusNumber;
controller->SharableVector = TRUE;
controller->SaveFloatState = FALSE;
//
// We need to get the following information out of the partial
// resource descriptors.
//
// The irql and vector.
//
// The dma channel.
//
// The base address and span covered by the floppy controllers
// registers.
//
// It is not defined how these appear in the partial resource
// lists, so we will just loop over all of them. If we find
// something we don't recognize, we drop that information on
// the floor. When we have finished going through all the
// partial information, we validate that we got the above
// three.
//
for (
i = 0;
i < controllerData->PartialResourceList.Count;
i++
) {
PCM_PARTIAL_RESOURCE_DESCRIPTOR partial =
&controllerData->PartialResourceList.PartialDescriptors[i];
switch (partial->Type) {
case CmResourceTypePort: {
foundPort = TRUE;
//
// Save of the pointer to the partial so
// that we can later use it to report resources
// and we can also use this later in the routine
// to make sure that we got all of our resources.
//
controller->SpanOfControllerAddress =
partial->u.Port.Length;
controller->OriginalBaseAddress =
partial->u.Port.Start;
controller->ResourcePortType =
!!partial->Flags;
controller->ControllerBaseAddress =
FlGetControllerBase(
BusType,
BusNumber,
partial->u.Port.Start,
controller->SpanOfControllerAddress,
(BOOLEAN)!!partial->Flags,
&controller->MappedAddress
);
if (!controller->ControllerBaseAddress) {
return STATUS_INSUFFICIENT_RESOURCES;
}
break;
}
case CmResourceTypeInterrupt: {
foundInterrupt = TRUE;
if (partial->Flags & CM_RESOURCE_INTERRUPT_LATCHED) {
controller->InterruptMode = Latched;
} else {
controller->InterruptMode = LevelSensitive;
}
controller->OriginalIrql = partial->u.Interrupt.Level;
controller->OriginalVector = partial->u.Interrupt.Vector;
controller->ControllerVector =
HalGetInterruptVector(
BusType,
BusNumber,
partial->u.Interrupt.Level,
partial->u.Interrupt.Vector,
&controller->ControllerIrql,
&controller->ProcessorMask
);
break;
}
case CmResourceTypeDma: {
DEVICE_DESCRIPTION deviceDesc = {0};
// Use IgnoreCount equal to TRUE to fix PS/1000.
foundDma = TRUE;
controller->OriginalDmaChannel = partial->u.Dma.Channel;
deviceDesc.Version = DEVICE_DESCRIPTION_VERSION1;
deviceDesc.DmaWidth = Width8Bits;
deviceDesc.DemandMode = TRUE;
deviceDesc.MaximumLength =
DriveMediaConstants[NUMBER_OF_DRIVE_MEDIA_COMBINATIONS-1].
BytesPerSector *
DriveMediaConstants[NUMBER_OF_DRIVE_MEDIA_COMBINATIONS-1].
SectorsPerTrack;
deviceDesc.IgnoreCount = TRUE;
//
// Always ask for one more page than maximum transfer size.
//
deviceDesc.MaximumLength += PAGE_SIZE;
deviceDesc.DmaChannel = partial->u.Dma.Channel;
deviceDesc.InterfaceType = BusType;
deviceDesc.DmaSpeed = TypeA;
controller->AdapterObject =
HalGetAdapter(
&deviceDesc,
&controller->NumberOfMapRegisters
);
if (!controller->AdapterObject) {
return STATUS_INSUFFICIENT_RESOURCES;
}
break;
}
default: {
break;
}
}
}
//
// If we didn't get all the information then we return
// insufficient resources.
//
if ((!foundPort) ||
(!foundInterrupt) ||
(!foundDma)) {
return STATUS_INSUFFICIENT_RESOURCES;
}
}
//
// With Version 2.0 or greater for this resource list, we will get
// the full int13 information for the drive. So get that if available.
//
// Otherwise, the only thing that we want out of the peripheral information
// is the maximum drive capacity.
//
//
// Drop any other information on the floor other then the
// device specfic floppy information.
//
for (
i = 0;
i < peripheralData->PartialResourceList.Count;
i++
) {
PCM_PARTIAL_RESOURCE_DESCRIPTOR partial =
&peripheralData->PartialResourceList.PartialDescriptors[i];
if (partial->Type == CmResourceTypeDeviceSpecific) {
//
// Point to right after this partial. This will take
// us to the beginning of the "real" device specific.
//
PCM_FLOPPY_DEVICE_DATA fDeviceData;
UCHAR driveType;
PDRIVE_MEDIA_CONSTANTS biosDriveMediaConstants =
&(controller->BiosDriveMediaConstants[controller->NumberOfDrives]);
fDeviceData = (PCM_FLOPPY_DEVICE_DATA)(partial + 1);
//
// Get the driver density
//
switch ( fDeviceData->MaxDensity ) {
case 360:
driveType = DRIVE_TYPE_0360;
break;
case 1200:
driveType = DRIVE_TYPE_1200;
break;
case 1185:
driveType = DRIVE_TYPE_1200;
break;
case 1423:
driveType = DRIVE_TYPE_1440;
break;
case 1440:
driveType = DRIVE_TYPE_1440;
break;
case 2880:
driveType = DRIVE_TYPE_2880;
break;
default:
FloppyDump(
FLOPDBGP,
("Floppy: Bad DriveCapacity!\n"
"------ density is %d\n",
fDeviceData->MaxDensity)
);
driveType = DRIVE_TYPE_1200;
FloppyDump(
FLOPDBGP,
("Floppy: run a setup program to set the floppy\n"
"------ drive type; assuming 1.2mb\n"
"------ (type is %x)\n",fDeviceData->MaxDensity)
);
break;
}
#if defined(DBCS) && defined(_MIPS_)
//
// Get the supported drive mode.
//
// If Size[0] is '3' and Size[1] is '.' and Size[2] is '5' and
// Size[6] is '3', the drive supports 3 mode. Otherwise, 2 mode.
//
//
if ((fDeviceData->Size[0] == '3') && (fDeviceData->Size[1] == '.') &&
(fDeviceData->Size[2] == '5') && (fDeviceData->Size[6] == '3')) {
controller->Drive3Mode[controller->NumberOfDrives] = DRIVE_3MODE;
} else {
controller->Drive3Mode[controller->NumberOfDrives] = DRIVE_2MODE;
}
#endif // DBCS && _MIPS_
controller->DriveType[controller->NumberOfDrives] = driveType;
//
// Pick up all the default from our own table and override
// with the BIOS information
//
*biosDriveMediaConstants = DriveMediaConstants[
DriveMediaLimits[driveType].HighestDriveMediaType];
//
// If the version is high enough, get the rest of the information.
// DeviceSpecific information with a version >= 2 should have
// this information
//
if (fDeviceData->Version >= 2) {
// biosDriveMediaConstants->MediaType =
biosDriveMediaConstants->StepRateHeadUnloadTime =
fDeviceData->StepRateHeadUnloadTime;
biosDriveMediaConstants->HeadLoadTime =
fDeviceData->HeadLoadTime;
biosDriveMediaConstants->MotorOffTime =
fDeviceData->MotorOffTime;
biosDriveMediaConstants->SectorLengthCode =
fDeviceData->SectorLengthCode;
// biosDriveMediaConstants->BytesPerSector =
if (fDeviceData->SectorPerTrack == 0) {
// This is not a valid sector per track value.
// We don't recognize this drive. This bogus
// value is often returned by SCSI floppies.
return STATUS_SUCCESS;
}
if (fDeviceData->MaxDensity == 0 ) {
//
// This values are returned by the LS-120 atapi drive.
// BIOS function 8, in int 13 is returned in bl, which is mapped
// to this field. The LS-120 returns 0x10 which is mapped to 0.
// Thats why we wont pick it up as a normal floppy.
//
return STATUS_SUCCESS;
}
biosDriveMediaConstants->SectorsPerTrack =
fDeviceData->SectorPerTrack;
biosDriveMediaConstants->ReadWriteGapLength =
fDeviceData->ReadWriteGapLength;
biosDriveMediaConstants->FormatGapLength =
fDeviceData->FormatGapLength;
biosDriveMediaConstants->FormatFillCharacter =
fDeviceData->FormatFillCharacter;
biosDriveMediaConstants->HeadSettleTime =
fDeviceData->HeadSettleTime;
biosDriveMediaConstants->MotorSettleTimeRead =
fDeviceData->MotorSettleTime * 1000 / 8;
biosDriveMediaConstants->MotorSettleTimeWrite =
fDeviceData->MotorSettleTime * 1000 / 8;
if (fDeviceData->MaximumTrackValue == 0) {
// This is not a valid maximum track value.
// We don't recognize this drive. This bogus
// value is often returned by SCSI floppies.
return STATUS_SUCCESS;
}
biosDriveMediaConstants->MaximumTrack =
fDeviceData->MaximumTrackValue;
// biosDriveMediaConstants->CylinderShift =
// NOTE CHICAGO does not use this value
//
//biosDriveMediaConstants->DataTransferRate =
// fDeviceData->DataTransferRate;
// biosDriveMediaConstants->NumberOfHeads =
biosDriveMediaConstants->DataLength =
fDeviceData->DataTransferLength;
}
}
}
controller->NumberOfDrives++;
controller->OkToUseThisController = TRUE;
return STATUS_SUCCESS;
}
NTSTATUS
FlGetConfigurationInformation(
OUT PCONFIG_DATA *ConfigData
)
/*++
Routine Description:
This routine is called by DriverEntry() to get information about the
devices to be supported from configuration mangement and/or the
hardware architecture layer (HAL).
Arguments:
ConfigData - a pointer to the pointer to a data structure that
describes the controllers and the drives attached to them
Return Value:
Returns STATUS_SUCCESS unless there is no drive 0 or we didn't get
any configuration information.
--*/
{
INTERFACE_TYPE InterfaceType;
NTSTATUS Status;
ULONG i;
*ConfigData = ExAllocatePool(PagedPool,
sizeof(CONFIG_DATA));
if (!*ConfigData) {
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Zero out the config structure and fill in the actual
// controller numbers with -1's so that the callback routine
// can recognize a new controller.
//
RtlZeroMemory(*ConfigData,
sizeof(CONFIG_DATA));
for (
i = 0;
i < MAXIMUM_CONTROLLERS_PER_MACHINE;
i++
) {
(*ConfigData)->Controller[i].ActualControllerNumber = -1;
}
//
// Go through all of the various bus types looking for
// disk controllers. The disk controller sections of the
// hardware registry only deal with the floppy drives.
// The callout routine that can get called will then
// look for information pertaining to a particular
// device on the controller.
//
for (
InterfaceType = 0;
InterfaceType < MaximumInterfaceType;
InterfaceType++
) {
CONFIGURATION_TYPE Dc = DiskController;
CONFIGURATION_TYPE Fp = FloppyDiskPeripheral;
Status = IoQueryDeviceDescription(&InterfaceType,
NULL,
&Dc,
NULL,
&Fp,
NULL,
FlConfigCallBack,
*ConfigData);
if (!NT_SUCCESS(Status) && (Status != STATUS_OBJECT_NAME_NOT_FOUND)) {
ExFreePool(*ConfigData);
*ConfigData = NULL;
return Status;
}
}
//
// Get a pointer to the Io system location that is keeping
// a count of all the floppy devices on the system.
//
if ( IoGetConfigurationInformation() == NULL ) {
FloppyDump(FLOPDBGP,
("Floppy: configuration information is NULL\n"));
ExFreePool(*ConfigData);
*ConfigData = NULL;
return STATUS_INSUFFICIENT_RESOURCES;
}
(*ConfigData)->FloppyCount = &IoGetConfigurationInformation()->FloppyCount;
return STATUS_SUCCESS;
}
BOOLEAN
FlReportResources(
IN PDRIVER_OBJECT DriverObject,
IN PCONFIG_DATA ConfigData,
IN UCHAR ControllerNumber
)
/*++
Routine Description:
This routine will build up a resource list using the
data for this particular controller as well as all
previous *successfully* configured controllers.
N.B. This routine assumes that it called in controller
number order.
Arguments:
DriverObject - a pointer to the object that represents this device
driver.
ConfigData - a pointer to the structure that describes the
controller and the disks attached to it, as given to us by the
configuration manager.
ControllerNumber - which controller in ConfigData we are
about to try to report.
Return Value:
TRUE if no conflict was detected, FALSE otherwise.
--*/
{
ULONG sizeOfResourceList;
ULONG numberOfFrds;
ULONG i;
PCM_RESOURCE_LIST resourceList;
PCM_FULL_RESOURCE_DESCRIPTOR nextFrd;
//
// Loop through all of the controllers previous to this
// controller. If the controllers previous to this one
// didn't have a conflict, then accumulate the size of the
// CM_FULL_RESOURCE_DESCRIPTOR associated with it.
//
for (
i = 0,numberOfFrds = 0,sizeOfResourceList = 0;
i <= ControllerNumber;
i++
) {
if (ConfigData->Controller[i].OkToUseThisController) {
sizeOfResourceList += sizeof(CM_FULL_RESOURCE_DESCRIPTOR);
//
// The full resource descriptor already contains one
// partial. Make room for three more.
//
// It will hold the irq "prd", the controller "csr" "prd" which
// is actually in two pieces since we don't use one of the
// registers, and the controller dma "prd".
//
sizeOfResourceList += 3*sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
numberOfFrds++;
}
}
//
// Now we increment the length of the resource list by field offset
// of the first frd. This will give us the length of what preceeds
// the first frd in the resource list.
//
sizeOfResourceList += FIELD_OFFSET(
CM_RESOURCE_LIST,
List[0]
);
resourceList = ExAllocatePool(
PagedPool,
sizeOfResourceList
);
if (!resourceList) {
return FALSE;
}
//
// Zero out the field
//
RtlZeroMemory(
resourceList,
sizeOfResourceList
);
resourceList->Count = numberOfFrds;
nextFrd = &resourceList->List[0];
for (
i = 0;
numberOfFrds;
i++
) {
if (ConfigData->Controller[i].OkToUseThisController) {
PCM_PARTIAL_RESOURCE_DESCRIPTOR partial;
nextFrd->InterfaceType = ConfigData->Controller[i].InterfaceType;
nextFrd->BusNumber = ConfigData->Controller[i].BusNumber;
//
// We are only going to report 4 items no matter what
// was in the original.
//
nextFrd->PartialResourceList.Count = 4;
//
// Now fill in the port data. We don't wish to share
// this port range with anyone
//
partial = &nextFrd->PartialResourceList.PartialDescriptors[0];
partial->Type = CmResourceTypePort;
partial->ShareDisposition = CmResourceShareShared;
partial->Flags = (USHORT)ConfigData->Controller[i].ResourcePortType;
partial->u.Port.Start =
ConfigData->Controller[i].OriginalBaseAddress;
partial->u.Port.Length = 6;
partial++;
partial->Type = CmResourceTypePort;
partial->ShareDisposition = CmResourceShareShared;
partial->Flags = (USHORT)ConfigData->Controller[i].ResourcePortType;
partial->u.Port.Start.QuadPart =
ConfigData->Controller[i].OriginalBaseAddress.QuadPart + 7;
partial->u.Port.Length = 1;
partial++;
partial->Type = CmResourceTypeDma;
partial->ShareDisposition = CmResourceShareShared;
partial->Flags = 0;
partial->u.Dma.Channel =
ConfigData->Controller[i].OriginalDmaChannel;
partial++;
//
// Now fill in the irq stuff.
//
partial->Type = CmResourceTypeInterrupt;
partial->u.Interrupt.Level =
ConfigData->Controller[i].OriginalIrql;
partial->u.Interrupt.Vector =
ConfigData->Controller[i].OriginalVector;
// if (nextFrd->InterfaceType == MicroChannel) {
//
// partial->ShareDisposition = CmResourceShareShared;
//
// } else {
//
// partial->ShareDisposition = CmResourceShareDriverExclusive;
//
// }
partial->ShareDisposition = CmResourceShareShared;
if (ConfigData->Controller[i].InterruptMode == Latched) {
partial->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
} else {
partial->Flags = CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE;
}
partial++;
nextFrd = (PVOID)partial;
numberOfFrds--;
}
}
IoReportResourceUsage(
NULL,
DriverObject,
resourceList,
sizeOfResourceList,
NULL,
NULL,
0,
FALSE,
&ConfigData->Controller[ControllerNumber].OkToUseThisController
);
//
// The above routine sets the boolean the parameter
// to TRUE if a conflict was detected.
//
ConfigData->Controller[ControllerNumber].OkToUseThisController =
!ConfigData->Controller[ControllerNumber].OkToUseThisController;
ExFreePool(resourceList);
return ConfigData->Controller[ControllerNumber].OkToUseThisController;
}
NTSTATUS
FlInitializeController(
IN PCONFIG_DATA ConfigData,
IN UCHAR ControllerNumber,
IN PDRIVER_OBJECT DriverObject,
IN ULONG NotConfigurable,
IN ULONG Model30
)
/*++
Routine Description:
This routine is called at initialization time by DriverEntry() -
once for each controller that the configuration manager tells it we
have to support.
When this routine is called, the configuration data has already been
filled in.
Arguments:
ConfigData - a pointer to the structure that describes the
controller and the disks attached to it, as given to us by the
configuration manager.
ControllerNumber - which controller in ConfigData we are
initializing.
DriverObject - a pointer to the object that represents this device
driver.
NotConfigurable - Supplies whether or not the controller is configurable.
Model30 - Supplies whether or not this is a model 30 floppy controller.
Return Value:
STATUS_SUCCESS if this controller and at least one of its disks were
initialized; an error otherwise.
--*/
{
PCONTROLLER_DATA controllerData;
NTSTATUS ntStatus;
NTSTATUS ntStatus2;
UCHAR driveNumber;
BOOLEAN partlySuccessful;
UCHAR ntNameBuffer[256];
STRING ntNameString;
UNICODE_STRING ntUnicodeString;
OBJECT_ATTRIBUTES objectAttributes;
FloppyDump(FLOPSHOW,
("Floppy: FlInitializeController...\n"));
//
// This routine will attempt to "append" the resources
// used by this controller into the resource map of the
// registry. If there was a conflict with previously "declared"
// data, then this routine will return false, in which case we
// will NOT try to initialize this particular controller.
//
if (!FlReportResources(DriverObject,
ConfigData,
ControllerNumber)) {
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Allocate and zero-initialize data to describe this controller
//
controllerData = (PCONTROLLER_DATA) ExAllocatePool(NonPagedPool,
sizeof(CONTROLLER_DATA));
if ( controllerData == NULL ) {
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory( controllerData, sizeof( CONTROLLER_DATA ) );
(VOID) sprintf(ntNameBuffer,
"\\Device\\FloppyControllerEvent%d",
ControllerNumber);
RtlInitString( &ntNameString, ntNameBuffer );
ntStatus = RtlAnsiStringToUnicodeString(&ntUnicodeString,
&ntNameString,
TRUE);
InitializeObjectAttributes(&objectAttributes,
&ntUnicodeString,
OBJ_PERMANENT | OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
NULL,
NULL);
controllerData->ControllerEvent = IoCreateSynchronizationEvent(
&ntUnicodeString,
&controllerData->ControllerEventHandle);
RtlFreeUnicodeString( &ntUnicodeString );
if ( !NT_SUCCESS( ntStatus ) ) {
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Stick the driver object into it so that we can use it to log
// an error if the controller hangs up.
//
controllerData->DriverObject = DriverObject;
//
// Fill in some items that we got from configuration management and
// the HAL.
//
controllerData->ControllerAddress =
ConfigData->Controller[ControllerNumber].ControllerBaseAddress;
controllerData->AdapterObject =
ConfigData->Controller[ControllerNumber].AdapterObject;
controllerData->NumberOfMapRegisters =
ConfigData->Controller[ControllerNumber].NumberOfMapRegisters;
controllerData->NumberOfDrives =
ConfigData->Controller[ControllerNumber].NumberOfDrives;
//
// Set the time to wait for an interrupt before timing out to a
// few seconds.
//
controllerData->InterruptDelay.QuadPart = -(10 * 1000 * 4000);
//
// Set the minimum time that we can delay (10ms according to system
// rules). This will be used when we have to delay to, say, wait
// for the FIFO - the FIFO should become ready is well under 10ms.
//
controllerData->Minimum10msDelay.QuadPart = -(10 * 1000 * 10);
//
// Occasionally during stress we've seen the device lock up.
// We create a dpc so that we can log that the device lock up
// occured and that we reset the device.
//
KeInitializeDpc(
&controllerData->LogErrorDpc,
FlLogErrorDpc,
controllerData
);
//
// Assume there is a CONFIGURE command until found otherwise.
// Other Booleans were zero-initialized to FALSE.
//
controllerData->ControllerConfigurable = NotConfigurable ? FALSE : TRUE;
controllerData->Model30 = Model30 ? TRUE : FALSE;
//
// Save interrupt information for connecting the interrupt later.
//
controllerData->ControllerVector = ConfigData->Controller[ControllerNumber].ControllerVector;
controllerData->ControllerIrql = ConfigData->Controller[ControllerNumber].ControllerIrql;
controllerData->ControllerIrql = ConfigData->Controller[ControllerNumber].ControllerIrql;
controllerData->InterruptMode = ConfigData->Controller[ControllerNumber].InterruptMode;
controllerData->SharableVector = ConfigData->Controller[ControllerNumber].SharableVector;
controllerData->ProcessorMask = ConfigData->Controller[ControllerNumber].ProcessorMask;
controllerData->SaveFloatState = ConfigData->Controller[ControllerNumber].SaveFloatState;
controllerData->AllowInterruptProcessing = controllerData->CurrentInterrupt = TRUE;
ntStatus = IoConnectInterrupt(
&controllerData->InterruptObject,
FloppyInterruptService,
controllerData,
NULL,
ConfigData->Controller[ControllerNumber].ControllerVector,
ConfigData->Controller[ControllerNumber].ControllerIrql,
ConfigData->Controller[ControllerNumber].ControllerIrql,
ConfigData->Controller[ControllerNumber].InterruptMode,
ConfigData->Controller[ControllerNumber].SharableVector,
ConfigData->Controller[ControllerNumber].ProcessorMask,
ConfigData->Controller[ControllerNumber].SaveFloatState);
controllerData->CurrentInterrupt = FALSE;
if (NT_SUCCESS(ntStatus)) {
//
// Initialize the interlocked request queue, including a
// counting semaphore to indicate items in the queue
//
KeInitializeSemaphore(
&controllerData->RequestSemaphore,
0L,
MAXLONG );
KeInitializeSpinLock( &controllerData->ListSpinLock );
ExInitializeFastMutex( &controllerData->ThreadReferenceMutex );
InitializeListHead( &controllerData->ListEntry );
controllerData->ThreadReferenceCount = -1;
//
// Initialize events to signal interrupts and adapter object
// allocation
//
KeInitializeEvent(
&controllerData->InterruptEvent,
SynchronizationEvent,
FALSE);
KeInitializeEvent(
&controllerData->AllocateAdapterChannelEvent,
NotificationEvent,
FALSE );
controllerData->AdapterChannelRefCount = 0;
//
// Call FlInitializeDrive() for each drive on the
// controller
//
ntStatus = STATUS_NO_SUCH_DEVICE;
partlySuccessful = FALSE;
for ( driveNumber = 0;
driveNumber < controllerData->NumberOfDrives;
driveNumber++ ) {
ntStatus = FlInitializeDrive(
ConfigData,
controllerData,
ControllerNumber,
driveNumber,
driveNumber,
DriverObject );
if ( NT_SUCCESS( ntStatus ) ) {
( *( ConfigData->FloppyCount ) )++;
partlySuccessful = TRUE;
}
}
if ( partlySuccessful ) {
ntStatus = STATUS_SUCCESS;
}
IoDisconnectInterrupt(controllerData->InterruptObject);
}
//
// If we're exiting with an error, clean up first.
//
if ( !NT_SUCCESS( ntStatus ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: InitializeController failing\n")
);
ExFreePool( controllerData );
}
return ntStatus;
}
NTSTATUS
FlInitializeControllerHardware(
IN PCONTROLLER_DATA ControllerData,
IN PDEVICE_OBJECT DeviceObject
)
/*++
Routine Description:
This routine is called at initialization time by FlInitializeDrive()
- once for each controller that we have to support. It is also
called by FlFinishOperation() when an operation appears to have
failed due to a hardware problem.
When this routine is called, the controller data structures have all
been allocated.
Arguments:
ControllerData - the completed data structure associated with the
controller hardware being initialized.
DeviceObject - a pointer to a device object; this routine will cause
an interrupt, and the ISR requires CurrentDeviceObject to be filled
in.
Return Value:
STATUS_SUCCESS if this controller appears to have been reset properly,
error otherwise.
--*/
{
NTSTATUS ntStatus;
UCHAR statusRegister0;
UCHAR cylinder;
UCHAR driveNumber;
UCHAR retrycnt;
PDISKETTE_EXTENSION disketteExtension;
FloppyDump(
FLOPSHOW,
("Floppy: FlInitializeControllerHardware...\n")
);
disketteExtension = DeviceObject->DeviceExtension;
for (retrycnt = 0; ; retrycnt++) {
//
// Reset the controller. This will cause an interrupt. Reset
// CurrentDeviceObject until after the 10ms wait, in case any
// stray interrupts come in.
//
ControllerData->DriveControlImage |= DRVCTL_ENABLE_DMA_AND_INTERRUPTS;
ControllerData->DriveControlImage &= ~( DRVCTL_ENABLE_CONTROLLER );
#ifdef _PPC_
ControllerData->DriveControlImage |= DRVCTL_DRIVE_MASK;
#endif
WRITE_CONTROLLER(
&ControllerData->ControllerAddress->DriveControl,
ControllerData->DriveControlImage );
KeStallExecutionProcessor( 10 );
ControllerData->CurrentDeviceObject = DeviceObject;
ControllerData->AllowInterruptProcessing = TRUE;
ControllerData->CommandHasResultPhase = FALSE;
KeResetEvent( &ControllerData->InterruptEvent );
ControllerData->DriveControlImage |= DRVCTL_ENABLE_CONTROLLER;
WRITE_CONTROLLER(
&ControllerData->ControllerAddress->DriveControl,
ControllerData->DriveControlImage );
//
// Wait for an interrupt. Note that STATUS_TIMEOUT and STATUS_SUCCESS
// are the only possible return codes, since we aren't alertable and
// won't get APCs.
//
ntStatus = KeWaitForSingleObject(
&ControllerData->InterruptEvent,
Executive,
KernelMode,
FALSE,
&ControllerData->InterruptDelay );
if (ntStatus == STATUS_TIMEOUT) {
if (retrycnt >= 1) {
break;
}
// Retry reset after configure command to enable polling
// interrupt.
ControllerData->FifoBuffer[0] = 0;
ControllerData->FifoBuffer[1] = COMMND_CONFIGURE_FIFO_THRESHOLD;
ControllerData->FifoBuffer[2] = 0;
ntStatus = FlIssueCommand(COMMND_CONFIGURE, disketteExtension);
if (!NT_SUCCESS(ntStatus)) {
ntStatus = STATUS_TIMEOUT;
break;
}
KeStallExecutionProcessor( 500 );
} else {
break;
}
}
if ( ntStatus == STATUS_TIMEOUT ) {
//
// Change info to an error.
//
ntStatus = STATUS_IO_TIMEOUT;
ControllerData->HardwareFailed = TRUE;
}
#ifdef KEEP_COUNTERS
FloppyThreadTime = KeQueryPerformanceCounter((PVOID)NULL);
FloppyThreadDelay.QuadPart = FloppyThreadDelay.QuadPart +
(FloppyDPCTime.QuadPart -
FloppyThreadTime.QuadPart);
FloppyFromIntrDelay.QuadPart = FloppyFromIntrDelay.QuadPart +
(FloppyIntrTime.QuadPart -
FloppyThreadTime.QuadPart);
FloppyThreadWake++;
#endif
if ( !NT_SUCCESS( ntStatus ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: controller didn't interrupt after reset\n")
);
return ntStatus;
}
//
// Sense interrupt status for all drives.
//
for ( driveNumber = 0;
( driveNumber < ControllerData->NumberOfDrives ) &&
( NT_SUCCESS( ntStatus ) );
driveNumber++ ) {
if ( driveNumber != 0 ) {
//
// Note that the ISR issued first SENSE INTERRUPT for us.
//
ntStatus = FlSendByte( COMMND_SENSE_INTERRUPT, ControllerData );
}
if ( NT_SUCCESS( ntStatus ) ) {
ntStatus = FlGetByte( &statusRegister0, ControllerData );
if ( NT_SUCCESS( ntStatus ) ) {
ntStatus = FlGetByte( &cylinder, ControllerData );
}
}
}
//
// Set PERPENDICULAR MODE for all drives that are perpendicular.
//
if ( ControllerData->PerpendicularDrives != 0 ) {
ntStatus = FlSendByte( COMMND_PERPENDICULAR_MODE, ControllerData );
if ( NT_SUCCESS( ntStatus ) ) {
ntStatus = FlSendByte( (UCHAR) (COMMND_PERPENDICULAR_MODE_OW |
(ControllerData->PerpendicularDrives << 2)),
ControllerData );
}
}
return ntStatus;
}
NTSTATUS
FlInitializeDrive(
IN PCONFIG_DATA ConfigData,
IN PCONTROLLER_DATA ControllerData,
IN UCHAR ControllerNum,
IN UCHAR DisketteNum,
IN UCHAR DisketteUnit,
IN PDRIVER_OBJECT DriverObject
)
/*++
Routine Description:
This routine is called at initialization time by
FlInitializeController(), once for each disk that we are supporting
on the controller.
Arguments:
ConfigData - a pointer to the structure that describes the
controller and the disks attached to it, as given to us by the
configuration manager.
ControllerData - a pointer to our data area for this controller.
ControllerNum - which controller in ConfigData we're working on.
DisketteNum - which logical disk on the current controller we're
working on.
DisketteUnit - which physical disk on the current controller we're
working on. Only different from DisketteNum when we're creating a
secondary device object for a previously initialized drive.
DriverObject - a pointer to the object that represents this device
driver.
Return Value:
STATUS_SUCCESS if this disk is initialized; an error otherwise.
--*/
{
UCHAR ntNameBuffer[256];
UCHAR arcNameBuffer[256];
STRING ntNameString;
STRING arcNameString;
UNICODE_STRING ntUnicodeString;
UNICODE_STRING arcUnicodeString;
NTSTATUS ntStatus;
PDEVICE_OBJECT deviceObject = NULL;
PDISKETTE_EXTENSION disketteExtension;
FloppyDump(
FLOPSHOW,
("Floppy: FlInitializeDrive...\n")
);
sprintf(
ntNameBuffer,
"\\Device\\Floppy%d",
*( ConfigData->FloppyCount ) );
RtlInitString( &ntNameString, ntNameBuffer );
ntStatus = RtlAnsiStringToUnicodeString(
&ntUnicodeString,
&ntNameString,
TRUE );
if ( NT_SUCCESS( ntStatus ) ) {
//
// Create a device object for this floppy drive.
//
ntStatus = IoCreateDevice(
DriverObject,
sizeof( DISKETTE_EXTENSION ),
&ntUnicodeString,
FILE_DEVICE_DISK,
FILE_REMOVABLE_MEDIA | FILE_FLOPPY_DISKETTE,
FALSE,
&deviceObject );
if ( NT_SUCCESS( ntStatus ) ) {
//
// Create a symbolic link from the disk name to the corresponding
// ARC name, to be used if we're booting off the disk. This will
// if it's not system initialization time; that's fine. The ARC
// name looks something like \ArcName\multi(0)disk(0)rdisk(0).
//
sprintf(
arcNameBuffer,
"%s(%d)disk(%d)fdisk(%d)",
"\\ArcName\\multi",
ConfigData->Controller[ControllerNum].BusNumber,
ConfigData->Controller[ControllerNum].ActualControllerNumber,
DisketteNum );
RtlInitString( &arcNameString, arcNameBuffer );
ntStatus = RtlAnsiStringToUnicodeString(
&arcUnicodeString,
&arcNameString,
TRUE );
if ( !NT_SUCCESS( ntStatus ) ) {
RtlFreeUnicodeString( &ntUnicodeString );
} else {
IoAssignArcName( &arcUnicodeString, &ntUnicodeString );
RtlFreeUnicodeString( &ntUnicodeString );
RtlFreeUnicodeString( &arcUnicodeString );
//
// Initialize the DPC structure in the device object, so that
// the ISR can queue DPCs.
//
IoInitializeDpcRequest( deviceObject, FloppyDeferredProcedure );
deviceObject->Flags |= DO_DIRECT_IO;
if ( deviceObject->AlignmentRequirement < FILE_WORD_ALIGNMENT ) {
deviceObject->AlignmentRequirement = FILE_WORD_ALIGNMENT;
}
//
// Copy the drive type from the configuration info; note that
// the media type has not been determined.
//
disketteExtension = deviceObject->DeviceExtension;
disketteExtension->ControllerData = ControllerData;
disketteExtension->DeviceObject = deviceObject;
disketteExtension->DeviceUnit = DisketteUnit;
disketteExtension->DriveOnValue = (UCHAR)( DisketteUnit |
( DRVCTL_ENABLE_CONTROLLER +
DRVCTL_ENABLE_DMA_AND_INTERRUPTS ) |
( DRVCTL_DRIVE_0 << DisketteUnit ) );
disketteExtension->IsReadOnly = FALSE;
disketteExtension->DriveType = ConfigData->
Controller[ControllerNum].DriveType[DisketteUnit];
disketteExtension->MediaType = Undetermined;
disketteExtension->BiosDriveMediaConstants = ConfigData->
Controller[ControllerNum].BiosDriveMediaConstants[DisketteUnit];
#if defined(DBCS) && defined(_MIPS_)
disketteExtension->Drive3Mode = ConfigData->
Controller[ControllerNum].Drive3Mode[DisketteUnit];
#endif // DBCS && _MIPS_
if ( disketteExtension->DriveType == DRIVE_TYPE_2880 ) {
ControllerData->PerpendicularDrives |= 1 << DisketteUnit;
}
//
// FlInitializeControllerHardware() should logically be called
// from FlInitializeController(). But the hardware can't be
// initialized until a device object exists, since the ISR has
// to queue a DPC. So we do it here, where we get a chance to
// clean up easily if FlInitializeControllerHardware() fails.
//
// The controller is normally only reset once, when the first
// diskette is initialized. But we'll try again on subsequent
// diskettes if it failed on the first one.
//
if ( ( DisketteNum == 0 ) ||
( disketteExtension->DriveType == DRIVE_TYPE_2880 ) ||
( ControllerData->HardwareFailed ) ) {
ControllerData->AllowInterruptProcessing = ControllerData->CurrentInterrupt = TRUE;
ntStatus = FlInitializeControllerHardware(
ControllerData,
deviceObject );
ControllerData->CurrentInterrupt = FALSE;
if ( NT_SUCCESS( ntStatus ) ) {
FloppyDump(
FLOPSHOW,
("Floppy: DriveType = %x\n",
disketteExtension->DriveType)
);
ControllerData->HardwareFailed = FALSE;
} else {
ControllerData->HardwareFailed = TRUE;
}
}
}
}
}
//
// If we're failing, clean up - stop the timer (it doesn't hurt to
// stop it even if it wasn't started) and delete the device object.
//
if ( !NT_SUCCESS( ntStatus ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: InitiaiizeDrive failing\n")
);
if ( deviceObject != NULL ) {
IoDeleteDevice( deviceObject );
}
}
return ntStatus;
}
NTSTATUS
FlQueueIrpToThread(
IN OUT PIRP Irp,
IN OUT PCONTROLLER_DATA ControllerData
)
/*++
Routine Description:
This routine queues the given irp to be serviced by the controller's
thread. If the thread is down then this routine creates the thread.
Arguments:
Irp - Supplies the IRP to queue to the controller's thread.
ControllerData - Supplies the controller data.
Return Value:
May return an error if PsCreateSystemThread fails.
Otherwise returns STATUS_PENDING and marks the IRP pending.
--*/
{
KIRQL oldIrql;
NTSTATUS status;
HANDLE threadHandle;
ExAcquireFastMutex(&ControllerData->ThreadReferenceMutex);
if (++(ControllerData->ThreadReferenceCount) == 0) {
ControllerData->ThreadReferenceCount++;
ExAcquireFastMutex(PagingMutex);
if (++PagingReferenceCount == 1) {
// Lock down the driver.
MmResetDriverPaging(DriverEntry);
}
ExReleaseFastMutex(PagingMutex);
// Create the thread.
status = PsCreateSystemThread(&threadHandle,
(ACCESS_MASK) 0L,
NULL,
(HANDLE) 0L,
NULL,
FloppyThread,
ControllerData);
if (!NT_SUCCESS(status)) {
ControllerData->ThreadReferenceCount = -1;
ExAcquireFastMutex(PagingMutex);
if (--PagingReferenceCount == 0) {
MmPageEntireDriver(DriverEntry);
}
ExReleaseFastMutex(PagingMutex);
ExReleaseFastMutex(&ControllerData->ThreadReferenceMutex);
return status;
}
ExReleaseFastMutex(&ControllerData->ThreadReferenceMutex);
ZwClose(threadHandle);
} else {
ExReleaseFastMutex(&ControllerData->ThreadReferenceMutex);
}
IoMarkIrpPending(Irp);
ExInterlockedInsertTailList(
&ControllerData->ListEntry,
&Irp->Tail.Overlay.ListEntry,
&ControllerData->ListSpinLock );
KeReleaseSemaphore(
&ControllerData->RequestSemaphore,
(KPRIORITY) 0,
1,
FALSE );
return STATUS_PENDING;
}
NTSTATUS
FloppyDispatchCreateClose(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine is called only rarely by the I/O system; it's mainly
for layered drivers to call. All it does is complete the IRP
successfully.
Arguments:
DeviceObject - a pointer to the object that represents the device
that I/O is to be done on.
Irp - a pointer to the I/O Request Packet for this request.
Return Value:
Always returns STATUS_SUCCESS, since this is a null operation.
--*/
{
UNREFERENCED_PARAMETER( DeviceObject );
FloppyDump(
FLOPSHOW,
("Floppy: DispatchCreateClose...\n")
);
//
// Null operation. Do not give an I/O boost since
// no I/O was actually done. IoStatus.Information should be
// FILE_OPENED for an open; it's undefined for a close.
//
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = FILE_OPENED;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return STATUS_SUCCESS;
}
NTSTATUS
FloppyDispatchDeviceControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine is called by the I/O system to perform a device I/O
control function.
Arguments:
DeviceObject - a pointer to the object that represents the device
that I/O is to be done on.
Irp - a pointer to the I/O Request Packet for this request.
Return Value:
STATUS_SUCCESS or STATUS_PENDING if recognized I/O control code,
STATUS_INVALID_DEVICE_REQUEST otherwise.
--*/
{
PIO_STACK_LOCATION irpSp;
PDISKETTE_EXTENSION disketteExtension;
PDISK_GEOMETRY outputBuffer;
NTSTATUS ntStatus;
ULONG outputBufferLength;
UCHAR i;
DRIVE_MEDIA_TYPE lowestDriveMediaType;
DRIVE_MEDIA_TYPE highestDriveMediaType;
ULONG formatExParametersSize;
PFORMAT_EX_PARAMETERS formatExParameters;
#if defined(DBCS) && defined(_MIPS_)
ULONG inputBufferLength;
ULONG inputBuffer;
#endif // DBCS && _MIPS_
FloppyDump(
FLOPSHOW,
("Floppy: DispatchDeviceControl...\n")
);
disketteExtension = DeviceObject->DeviceExtension;
irpSp = IoGetCurrentIrpStackLocation( Irp );
switch( irpSp->Parameters.DeviceIoControl.IoControlCode ) {
case IOCTL_DISK_FORMAT_TRACKS:
case IOCTL_DISK_FORMAT_TRACKS_EX:
//
// Make sure that we got all the necessary format parameters.
//
if ( irpSp->Parameters.DeviceIoControl.InputBufferLength <
sizeof( FORMAT_PARAMETERS ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: invalid FORMAT buffer length\n")
);
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
//
// Make sure the parameters we got are reasonable.
//
if ( !FlCheckFormatParameters(
disketteExtension,
(PFORMAT_PARAMETERS) Irp->AssociatedIrp.SystemBuffer ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: invalid FORMAT parameters\n")
);
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
//
// If this is an EX request then make a couple of extra checks
//
if (irpSp->Parameters.DeviceIoControl.IoControlCode ==
IOCTL_DISK_FORMAT_TRACKS_EX) {
if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
sizeof(FORMAT_EX_PARAMETERS)) {
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
formatExParameters = (PFORMAT_EX_PARAMETERS)
Irp->AssociatedIrp.SystemBuffer;
formatExParametersSize =
FIELD_OFFSET(FORMAT_EX_PARAMETERS, SectorNumber) +
formatExParameters->SectorsPerTrack*sizeof(USHORT);
if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
formatExParametersSize ||
formatExParameters->FormatGapLength >= 0x100 ||
formatExParameters->SectorsPerTrack >= 0x100) {
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
}
//
// Fall through to queue the request.
//
case IOCTL_DISK_CHECK_VERIFY:
case IOCTL_DISK_GET_DRIVE_GEOMETRY:
case IOCTL_DISK_IS_WRITABLE:
//
// The thread must know which diskette to operate on, but the
// request list only passes the IRP. So we'll stick a pointer
// to the diskette extension in Type3InputBuffer, which is
// a field that isn't used for floppy ioctls.
//
//
// Add the request to the queue, and wake up the thread to
// process it.
//
irpSp->Parameters.DeviceIoControl.Type3InputBuffer = (PVOID)
disketteExtension;
FloppyDump(
FLOPIRPPATH,
("Floppy: Enqueing up IRP: %x\n",Irp)
);
ntStatus = FlQueueIrpToThread(Irp,
disketteExtension->ControllerData);
break;
case IOCTL_DISK_GET_MEDIA_TYPES: {
FloppyDump(
FLOPSHOW,
("Floppy: IOCTL_DISK_GET_MEDIA_TYPES called\n")
);
lowestDriveMediaType = DriveMediaLimits[
disketteExtension->DriveType].LowestDriveMediaType;
highestDriveMediaType = DriveMediaLimits[
disketteExtension->DriveType].HighestDriveMediaType;
outputBufferLength =
irpSp->Parameters.DeviceIoControl.OutputBufferLength;
//
// Make sure that the input buffer has enough room to return
// at least one descriptions of a supported media type.
//
if ( outputBufferLength < ( sizeof( DISK_GEOMETRY ) ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: invalid GET_MEDIA_TYPES buffer size\n")
);
ntStatus = STATUS_BUFFER_TOO_SMALL;
break;
}
//
// Assume success, although we might modify it to a buffer
// overflow warning below (if the buffer isn't big enough
// to hold ALL of the media descriptions).
//
ntStatus = STATUS_SUCCESS;
if ( outputBufferLength < ( sizeof( DISK_GEOMETRY ) *
( highestDriveMediaType - lowestDriveMediaType + 1 ) ) ) {
//
// The buffer is too small for all of the descriptions;
// calculate what CAN fit in the buffer.
//
FloppyDump(
FLOPDBGP,
("Floppy: GET_MEDIA_TYPES buffer size too small\n")
);
ntStatus = STATUS_BUFFER_OVERFLOW;
highestDriveMediaType = (DRIVE_MEDIA_TYPE)( ( lowestDriveMediaType - 1 ) +
( outputBufferLength /
sizeof( DISK_GEOMETRY ) ) );
}
outputBuffer = (PDISK_GEOMETRY) Irp->AssociatedIrp.SystemBuffer;
for (
i = (UCHAR)lowestDriveMediaType;
i <= (UCHAR)highestDriveMediaType;
i++ ) {
outputBuffer->MediaType = DriveMediaConstants[i].MediaType;
outputBuffer->Cylinders.LowPart =
DriveMediaConstants[i].MaximumTrack + 1;
outputBuffer->Cylinders.HighPart = 0;
outputBuffer->TracksPerCylinder =
DriveMediaConstants[i].NumberOfHeads;
outputBuffer->SectorsPerTrack =
DriveMediaConstants[i].SectorsPerTrack;
outputBuffer->BytesPerSector =
DriveMediaConstants[i].BytesPerSector;
FloppyDump(
FLOPSHOW,
("Floppy: media types supported [%d]\n"
"------- Cylinders low: 0x%x\n"
"------- Cylinders high: 0x%x\n"
"------- Track/Cyl: 0x%x\n"
"------- Sectors/Track: 0x%x\n"
"------- Bytes/Sector: 0x%x\n"
"------- Media Type: %d\n",
i,
outputBuffer->Cylinders.LowPart,
outputBuffer->Cylinders.HighPart,
outputBuffer->TracksPerCylinder,
outputBuffer->SectorsPerTrack,
outputBuffer->BytesPerSector,
outputBuffer->MediaType)
);
outputBuffer++;
Irp->IoStatus.Information += sizeof( DISK_GEOMETRY );
}
break;
}
#if defined(DBCS) && defined(_MIPS_)
case IOCTL_DISK_GET_REMOVABLE_TYPES: {
outputBufferLength =
irpSp->Parameters.DeviceIoControl.OutputBufferLength;
//
// Make sure that the input buffer has enough room to return
// at least one descriptions of a supported media type.
//
if ( outputBufferLength < ( sizeof( DDRIVE_TYPE ) ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: invalid GET_REMOVABLE_TYPES buffer size\n")
);
ntStatus = STATUS_BUFFER_TOO_SMALL;
break;
}
(PDDRIVE_TYPE) outputBuffer
= (PDDRIVE_TYPE) Irp->AssociatedIrp.SystemBuffer;
((PDDRIVE_TYPE)outputBuffer)->DDrive_Type = 1;
Irp->IoStatus.Information = sizeof( DDRIVE_TYPE );
ntStatus = STATUS_SUCCESS;
break;
}
case IOCTL_DISK_SET_MEDIA_TYPE: {
FloppyDump(
FLOPDBGP,
("Floppy: SET_MEDIA_TYPE \n")
);
outputBufferLength =
irpSp->Parameters.DeviceIoControl.OutputBufferLength;
//
// Make sure that the input buffer has enough room to return
// at least one descriptions of a supported media type.
//
if ( outputBufferLength < ( sizeof( MEDIA_TYPE_PTOS ) ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: invalid SET_MEDIA_TYPE buffer size\n")
);
ntStatus = STATUS_BUFFER_TOO_SMALL;
break;
}
(PMEDIA_TYPE_PTOS)outputBuffer
=(PMEDIA_TYPE_PTOS)Irp->AssociatedIrp.SystemBuffer;
Set_Media_Type_PTOS[disketteExtension->DeviceUnit].Media_Type_PTOS
=((PMEDIA_TYPE_PTOS)outputBuffer)->Media_Type_PTOS;
ntStatus = STATUS_SUCCESS;
break;
}
case IOCTL_DISK_READ:
case IOCTL_DISK_WRITE: {
FloppyDump(
FLOPDBGP,
("Floppy: IOCTL READ WRITE \n")
);
//
// Make sure that we got all the necessary IOCTL read write parameters.
//
if ( irpSp->Parameters.DeviceIoControl.InputBufferLength <
sizeof( DISK_READ_WRITE_PARAMETER_PTOS ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: invalid IOCTL READ WRITE buffer length\n")
);
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
irpSp->Parameters.DeviceIoControl.Type3InputBuffer = (PVOID)
disketteExtension;
FloppyDump(
FLOPIRPPATH,
("Floppy: Enqueing up IRP: %x\n",Irp)
);
ntStatus = FlQueueIrpToThread(Irp,
disketteExtension->ControllerData);
break;
}
case IOCTL_DISK_GET_STATUS: {
FloppyDump(
FLOPDBGP,
("Floppy: GET_STATUS \n")
);
outputBufferLength =
irpSp->Parameters.DeviceIoControl.OutputBufferLength;
//
// Make sure that the input buffer has enough room to return
// at least one descriptions of a supported media type.
//
if ( outputBufferLength < ( sizeof( RESULT_STATUS_PTOS ) ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: invalid GET_STATUS buffer size\n")
);
ntStatus = STATUS_BUFFER_TOO_SMALL;
break;
}
(PRESULT_STATUS_PTOS)inputBuffer
=(PRESULT_STATUS_PTOS)Irp->AssociatedIrp.SystemBuffer;
((PRESULT_STATUS_PTOS)inputBuffer)->ST0_PTOS
=Result_Status_PTOS[0].ST0_PTOS;
((PRESULT_STATUS_PTOS)inputBuffer)->ST1_PTOS
=Result_Status_PTOS[0].ST1_PTOS;
((PRESULT_STATUS_PTOS)inputBuffer)->ST2_PTOS
=Result_Status_PTOS[0].ST2_PTOS;
((PRESULT_STATUS_PTOS)inputBuffer)->C_PTOS
=Result_Status_PTOS[0].C_PTOS;
((PRESULT_STATUS_PTOS)inputBuffer)->H_PTOS
=Result_Status_PTOS[0].H_PTOS;
((PRESULT_STATUS_PTOS)inputBuffer)->R_PTOS
=Result_Status_PTOS[0].R_PTOS;
((PRESULT_STATUS_PTOS)inputBuffer)->N_PTOS
=Result_Status_PTOS[0].N_PTOS;
Irp->IoStatus.Information = sizeof( RESULT_STATUS_PTOS );
ntStatus = STATUS_SUCCESS;
break;
}
case IOCTL_DISK_SENSE_DEVICE: {
FloppyDump(
FLOPDBGP,
("Floppy: SENSE_DEVISE_STATUS \n")
);
//
// Make sure that we got all the necessary IOCTL read write parameters.
//
if ( irpSp->Parameters.DeviceIoControl.OutputBufferLength <
sizeof( SENSE_DEVISE_STATUS_PTOS ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: invalid SENSE_DEVISE_STATUS buffer length\n")
);
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
irpSp->Parameters.DeviceIoControl.Type3InputBuffer = (PVOID)
disketteExtension;
FloppyDump(
FLOPIRPPATH,
("Floppy: Enqueing up IRP: %x\n",Irp)
);
ntStatus = FlQueueIrpToThread(Irp,
disketteExtension->ControllerData);
break;
}
#endif // DBCS && _MIPS_
default: {
FloppyDump(
FLOPDBGP,
("Floppy: invalid device request %x\n",
irpSp->Parameters.DeviceIoControl.IoControlCode)
);
ntStatus = STATUS_INVALID_DEVICE_REQUEST;
break;
}
}
if ( ntStatus != STATUS_PENDING ) {
Irp->IoStatus.Status = ntStatus;
if (!NT_SUCCESS( ntStatus ) &&
IoIsErrorUserInduced( ntStatus )) {
IoSetHardErrorOrVerifyDevice( Irp, DeviceObject );
}
IoCompleteRequest( Irp, IO_NO_INCREMENT );
}
return ntStatus;
}
NTSTATUS
FloppyDispatchReadWrite(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine is called by the I/O system to read or write to a
device that we control.
Arguments:
DeviceObject - a pointer to the object that represents the device
that I/O is to be done on.
Irp - a pointer to the I/O Request Packet for this request.
Return Value:
STATUS_INVALID_PARAMETER if parameters are invalid,
STATUS_PENDING otherwise.
--*/
{
PIO_STACK_LOCATION irpSp;
NTSTATUS ntStatus;
PDISKETTE_EXTENSION disketteExtension;
FloppyDump(
FLOPSHOW,
("Floppy: FloppyDispatchReadWrite...\n")
);
disketteExtension = DeviceObject->DeviceExtension;
irpSp = IoGetCurrentIrpStackLocation( Irp );
if ( ( disketteExtension->MediaType > Unknown ) &&
( ( ( irpSp->Parameters.Read.ByteOffset ).LowPart +
irpSp->Parameters.Read.Length > disketteExtension->ByteCapacity ) ||
( ( irpSp->Parameters.Read.Length &
( disketteExtension->BytesPerSector - 1 ) ) != 0 ) ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: Invalid Parameter, rejecting request\n")
);
FloppyDump(
FLOPWARN,
("Floppy: Starting offset = %lx\n"
"------ I/O Length = %lx\n"
"------ ByteCapacity = %lx\n"
"------ BytesPerSector = %lx\n",
irpSp->Parameters.Read.ByteOffset.LowPart,
irpSp->Parameters.Read.Length,
disketteExtension->ByteCapacity,
disketteExtension->BytesPerSector)
);
ntStatus = STATUS_INVALID_PARAMETER;
} else {
//
// We need to pass the disketteExtension somewhere in the irp.
// The "Key" field in our stack location should be unused.
//
irpSp->Parameters.Read.Key = (ULONG) disketteExtension;
FloppyDump(
FLOPIRPPATH,
("Floppy: Enqueing up IRP: %x\n",Irp)
);
ntStatus = FlQueueIrpToThread(Irp, disketteExtension->ControllerData);
}
if (ntStatus != STATUS_PENDING) {
Irp->IoStatus.Status = ntStatus;
IoCompleteRequest(Irp, 0);
}
return ntStatus;
}
BOOLEAN
FloppyInterruptService(
IN PKINTERRUPT Interrupt,
IN PVOID Context
)
/*++
Routine Description:
This routine is called at DIRQL by the system when the controller
interrupts.
Arguments:
Interrupt - a pointer to the interrupt object.
Context - a pointer to our controller data area for the controller
that interrupted. (This was set up by the call to
IoConnectInterrupt).
Return Value:
Normally returns TRUE, but will return FALSE if this interrupt was
not expected.
--*/
{
PCONTROLLER_DATA controllerData;
PDEVICE_OBJECT currentDeviceObject;
ULONG i;
UCHAR statusByte;
BOOLEAN controllerStateError;
UNREFERENCED_PARAMETER( Interrupt );
#ifdef KEEP_COUNTERS
FloppyIntrTime = KeQueryPerformanceCounter((PVOID)NULL);
FloppyInterrupts++;
#endif
FloppyDump(
FLOPSHOW,
("FloppyInterruptService: ")
);
controllerData = (PCONTROLLER_DATA) Context;
if (!controllerData->AllowInterruptProcessing) {
FloppyDump(
FLOPSHOW,
("processing not allowed\n")
);
return FALSE;
}
//
// CurrentDeviceObject is set to the device object that is
// expecting an interrupt.
//
currentDeviceObject = controllerData->CurrentDeviceObject;
controllerData->CurrentDeviceObject = NULL;
controllerStateError = FALSE;
KeStallExecutionProcessor(10);
if ( controllerData->CommandHasResultPhase ) {
//
// Result phase of previous command. (Note that we can't trust
// the CMD_BUSY bit in the status register to tell us whether
// there's result bytes or not; it's sometimes wrong).
// By reading the first result byte, we reset the interrupt.
// The other result bytes will be read by a thread.
// Note that we want to do this even if the interrupt is
// unexpected, to make sure the interrupt is dismissed.
//
FloppyDump(
FLOPSHOW,
("have result phase\n")
);
if ( ( READ_CONTROLLER( &controllerData->ControllerAddress->Status )
& STATUS_IO_READY_MASK ) == STATUS_READ_READY ) {
controllerData->FifoBuffer[0] =
READ_CONTROLLER( &controllerData->ControllerAddress->Fifo );
FloppyDump(
FLOPSHOW,
("FloppyInterruptService: 1st fifo byte %2x\n", controllerData->FifoBuffer[0])
);
} else {
//
// Should never get here. If we do, DON'T wake up the thread;
// let it time out and reset the controller, or let another
// interrupt handle this.
//
FloppyDump(
FLOPDBGP,
("FloppyInterruptService: controller not ready to be read in ISR\n")
);
controllerStateError = TRUE;
}
} else {
//
// Previous command doesn't have a result phase. To read how it
// completed, issue a sense interrupt command. Don't read
// the result bytes from the sense interrupt; that is the
// responsibility of the calling thread.
// Note that we want to do this even if the interrupt is
// unexpected, to make sure the interrupt is dismissed.
//
FloppyDump(
FLOPSHOW,
("no result phase\n")
);
i = 0;
do {
KeStallExecutionProcessor( 1 );
statusByte = READ_CONTROLLER(&controllerData->ControllerAddress->Status);
i++;
} while ( ( i < FIFO_ISR_TIGHTLOOP_RETRY_COUNT ) &&
( ( statusByte & STATUS_CONTROLLER_BUSY ) ||
( ( statusByte & STATUS_IO_READY_MASK ) != STATUS_WRITE_READY ) ) );
if ( !( statusByte & STATUS_CONTROLLER_BUSY ) &&
( ( statusByte & STATUS_IO_READY_MASK ) == STATUS_WRITE_READY ) ) {
WRITE_CONTROLLER(
&controllerData->ControllerAddress->Fifo,
COMMND_SENSE_INTERRUPT );
//
// Wait for the controller to ACK the SenseInterrupt command, by
// showing busy. On very fast machines we can end up running
// driver's system-thread before the controller has had time to
// set the busy bit.
//
for (i = ISR_SENSE_RETRY_COUNT; i; i--) {
statusByte = READ_CONTROLLER( &controllerData->ControllerAddress->Status );
if (statusByte & STATUS_CONTROLLER_BUSY) {
break;
}
KeStallExecutionProcessor( 1 );
}
if (!i) {
FloppyDump(
FLOPSHOW,
("FloppyInterruptService: spin loop complete and controller NOT busy\n")
);
}
if ( currentDeviceObject == NULL ) {
//
// This is an unexpected interrupt, so nobody's going to
// read the result bytes. Read them now.
//
FloppyDump(
FLOPSHOW,
("FloppyInterruptService: Dumping fifo bytes!\n")
);
READ_CONTROLLER( &controllerData->ControllerAddress->Fifo );
READ_CONTROLLER( &controllerData->ControllerAddress->Fifo );
}
} else {
//
// Shouldn't get here. If we do, DON'T wake up the thread;
// let it time out and reset the controller, or let another
// interrupt take care of it.
//
FloppyDump(
FLOPDBGP,
("Floppy: no result, but can't write SenseIntr\n")
);
controllerStateError = TRUE;
}
}
//
// We've written to the controller, and we're about to leave. On
// machines with levelsensitive interrupts, we'll get another interrupt
// if we RETURN before the port is flushed. To make sure that doesn't
// happen, we'll do a read here.
//
statusByte = READ_CONTROLLER( &controllerData->ControllerAddress->Status );
//
// Let the interrupt settle.
//
KeStallExecutionProcessor(10);
#ifdef KEEP_COUNTERS
FloppyEndIntrTime = KeQueryPerformanceCounter((PVOID)NULL);
FloppyIntrDelay.QuadPart = FloppyIntrDelay.QuadPart +
(FloppyEndIntrTime.QuadPart -
FloppyIntrTime.QuadPart);
#endif
if ( currentDeviceObject == NULL ) {
//
// We didn't expect this interrupt. We've dismissed it just
// in case, but now return FALSE withOUT waking up the thread.
//
FloppyDump(FLOPDBGP,
("Floppy: unexpected interrupt\n"));
return FALSE;
}
if ( !controllerStateError ) {
//
// Request a DPC for execution later to get the remainder of the
// floppy state.
//
controllerData->IsrReentered = 0;
controllerData->AllowInterruptProcessing = FALSE;
IoRequestDpc(currentDeviceObject,
currentDeviceObject->CurrentIrp,
(PVOID) NULL);
} else {
//
// Running the floppy (at least on R4000 boxes) we've seen
// examples where the device interrupts, yet it never says
// it *ISN'T* busy. If this ever happens on non-MCA x86 boxes
// it would be ok since we use latched interrupts. Even if
// the device isn't touched so that the line would be pulled
// down, on the latched machine, this ISR wouldn't be called
// again. The normal timeout code for a request would eventually
// reset the controller and retry the request.
//
// On the R4000 boxes and on MCA machines, the floppy is using
// level sensitive interrupts. Therefore if we don't do something
// to lower the interrupt line, we will be called over and over,
// *forever*. This makes it look as though the machine is hung.
// Unless we were lucky enough to be on a multiprocessor, the
// normal timeout code would NEVER get a chance to run because
// the timeout code runs at dispatch level, and we will never
// leave device level.
//
// What we will do is keep a counter that is incremented every
// time we reach this section of code. When the counter goes
// over the threshold we will do a hard reset of the device
// and reset the counter down to zero. The counter will be
// initialized when the device is first initialized. It will
// be set to zero in the other arm of this if, and it will be
// reset to zero by the normal timeout logic.
//
controllerData->CurrentDeviceObject = currentDeviceObject;
if (controllerData->IsrReentered > FLOPPY_RESET_ISR_THRESHOLD) {
//
// Reset the controller. This could cause an interrupt
//
controllerData->IsrReentered = 0;
controllerData->DriveControlImage |= DRVCTL_ENABLE_DMA_AND_INTERRUPTS;
controllerData->DriveControlImage &= ~( DRVCTL_ENABLE_CONTROLLER );
#ifdef _PPC_
controllerData->DriveControlImage |= DRVCTL_DRIVE_MASK;
#endif
WRITE_CONTROLLER(&controllerData->ControllerAddress->DriveControl,
controllerData->DriveControlImage);
KeStallExecutionProcessor( 10 );
controllerData->DriveControlImage |= DRVCTL_ENABLE_CONTROLLER;
WRITE_CONTROLLER(&controllerData->ControllerAddress->DriveControl,
controllerData->DriveControlImage);
//
// Give the device plenty of time to be reset and
// interrupt again. Then just do the sense interrupt.
// this should quiet the device. We will then let
// the normal timeout code do its work.
//
KeStallExecutionProcessor(500);
WRITE_CONTROLLER(&controllerData->ControllerAddress->Fifo,
COMMND_SENSE_INTERRUPT);
KeStallExecutionProcessor(500);
KeInsertQueueDpc(&controllerData->LogErrorDpc,
NULL,
NULL);
} else {
controllerData->IsrReentered++;
}
}
return TRUE;
}
VOID
FloppyDeferredProcedure(
IN PKDPC Dpc,
IN PVOID DeferredContext,
IN PVOID SystemArgument1,
IN PVOID SystemArgument2
)
/*++
Routine Description:
This routine is called at DISPATCH_LEVEL by the system at the
request of FloppyInterruptService(). It simply sets the interrupt
event, which wakes up the floppy thread.
Arguments:
Dpc - a pointer to the DPC object used to invoke this routine.
DeferredContext - a pointer to the device object associated with this
DPC.
SystemArgument1 - unused.
SystemArgument2 - unused.
Return Value:
None.
--*/
{
PDEVICE_OBJECT deviceObject;
PDISKETTE_EXTENSION disketteExtension;
UNREFERENCED_PARAMETER( Dpc );
UNREFERENCED_PARAMETER( SystemArgument1 );
UNREFERENCED_PARAMETER( SystemArgument2 );
#ifdef KEEP_COUNTERS
FloppyDPCs++;
FloppyDPCTime = KeQueryPerformanceCounter((PVOID)NULL);
FloppyDPCDelay.QuadPart = FloppyDPCDelay.QuadPart +
(FloppyDPCTime.QuadPart -
FloppyIntrTime.QuadPart);
#endif
deviceObject = (PDEVICE_OBJECT) DeferredContext;
disketteExtension = deviceObject->DeviceExtension;
KeSetEvent(
&disketteExtension->ControllerData->InterruptEvent,
(KPRIORITY) 0,
FALSE );
}
NTSTATUS
FlSendByte(
IN UCHAR ByteToSend,
IN PCONTROLLER_DATA ControllerData
)
/*++
Routine Description:
This routine is called to send a byte to the controller. It won't
send the byte unless the controller is ready to receive a byte; if
it's not ready after checking FIFO_TIGHTLOOP_RETRY_COUNT times, we
delay for the minimum possible time (10ms) and then try again. It
should always be ready after waiting 10ms.
Arguments:
ByteToSend - the byte to send to the controller.
ControllerData - a pointer to our data area for this controller.
Return Value:
STATUS_SUCCESS if the byte was sent to the controller;
STATUS_DEVICE_NOT_READY otherwise.
--*/
{
ULONG i = 0;
BOOLEAN byteWritten = FALSE;
//
// Sit in a tight loop for a while. If the controller becomes ready,
// send the byte.
//
do {
if ( ( READ_CONTROLLER( &ControllerData->ControllerAddress->Status )
& STATUS_IO_READY_MASK ) == STATUS_WRITE_READY ) {
WRITE_CONTROLLER(
&ControllerData->ControllerAddress->Fifo,
ByteToSend );
byteWritten = TRUE;
} else {
KeStallExecutionProcessor(1);
}
i++;
} while ( (!byteWritten) && ( i < FIFO_TIGHTLOOP_RETRY_COUNT ) );
//
// We hope that in most cases the FIFO will become ready very quickly
// and the above loop will have written the byte. But if the FIFO
// is not yet ready, we'll loop a few times delaying for 10ms and then
// try it again.
//
i = 0;
while ( ( !byteWritten ) && ( i < FIFO_DELAY_RETRY_COUNT ) ) {
FloppyDump(
FLOPINFO,
("Floppy: waiting for 10ms for controller write\n")
);
KeDelayExecutionThread(
KernelMode,
FALSE,
&ControllerData->Minimum10msDelay );
i++;
if ( (READ_CONTROLLER( &ControllerData->ControllerAddress->Status )
& STATUS_IO_READY_MASK) == STATUS_WRITE_READY ) {
WRITE_CONTROLLER(
&ControllerData->ControllerAddress->Fifo,
ByteToSend );
byteWritten = TRUE;
}
}
if ( byteWritten ) {
return STATUS_SUCCESS;
} else {
//
// We've waited over 30ms, and the FIFO *still* isn't ready.
// Return an error.
//
FloppyDump(
FLOPWARN,
("Floppy: FIFO not ready to write after 30ms\n")
);
ControllerData->HardwareFailed = TRUE;
return STATUS_DEVICE_NOT_READY;
}
}
NTSTATUS
FlGetByte(
OUT PUCHAR ByteToGet,
IN PCONTROLLER_DATA ControllerData
)
/*++
Routine Description:
This routine is called to get a byte from the controller. It won't
read the byte unless the controller is ready to send a byte; if
it's not ready after checking FIFO_RETRY_COUNT times, we delay for
the minimum possible time (10ms) and then try again. It should
always be ready after waiting 10ms.
Arguments:
ByteToGet - the address in which the byte read from the controller
is stored.
ControllerData - a pointer to our data area for this controller.
Return Value:
STATUS_SUCCESS if a byte was read from the controller;
STATUS_DEVICE_NOT_READY otherwise.
--*/
{
ULONG i = 0;
BOOLEAN byteRead = FALSE;
//
// Sit in a tight loop for a while. If the controller becomes ready,
// read the byte.
//
do {
if ( ( READ_CONTROLLER( &ControllerData->ControllerAddress->Status )
& STATUS_IO_READY_MASK ) == STATUS_READ_READY ) {
*ByteToGet = READ_CONTROLLER(
&ControllerData->ControllerAddress->Fifo );
byteRead = TRUE;
} else {
KeStallExecutionProcessor(1);
}
i++;
} while ( ( !byteRead ) && ( i < FIFO_TIGHTLOOP_RETRY_COUNT ) );
//
// We hope that in most cases the FIFO will become ready very quickly
// and the above loop will have read the byte. But if the FIFO
// is not yet ready, we'll loop a few times delaying for 10ms and then
// trying it again.
//
i = 0;
while ( ( !byteRead ) && ( i < FIFO_DELAY_RETRY_COUNT ) ) {
FloppyDump(
FLOPINFO,
("Floppy: waiting for 10ms for controller read\n")
);
KeDelayExecutionThread(
KernelMode,
FALSE,
&ControllerData->Minimum10msDelay );
i++;
if ( (READ_CONTROLLER( &ControllerData->ControllerAddress->Status )
& STATUS_IO_READY_MASK) == STATUS_READ_READY ) {
*ByteToGet = READ_CONTROLLER(
&ControllerData->ControllerAddress->Fifo );
byteRead = TRUE;
}
}
if ( byteRead ) {
return STATUS_SUCCESS;
} else {
//
// We've waited over 30ms, and the FIFO *still* isn't ready.
// Return an error.
//
FloppyDump(
FLOPWARN,
("Floppy: FIFO not ready to read after 30ms\n")
);
ControllerData->HardwareFailed = TRUE;
return STATUS_DEVICE_NOT_READY;
}
}
NTSTATUS
FlInterpretError(
IN UCHAR StatusRegister1,
IN UCHAR StatusRegister2
)
/*++
Routine Description:
This routine is called when the floppy controller returns an error.
Status registers 1 and 2 are passed in, and this returns an appropriate
error status.
Arguments:
StatusRegister1 - the controller's status register #1.
StatusRegister2 - the controller's status register #2.
Return Value:
An NTSTATUS error determined from the status registers.
--*/
{
if ( ( StatusRegister1 & STREG1_CRC_ERROR ) ||
( StatusRegister2 & STREG2_CRC_ERROR ) ) {
FloppyDump(
FLOPSHOW,
("FlInterpretError: STATUS_CRC_ERROR\n")
);
return STATUS_CRC_ERROR;
}
if ( StatusRegister1 & STREG1_DATA_OVERRUN ) {
FloppyDump(
FLOPSHOW,
("FlInterpretError: STATUS_DATA_OVERRUN\n")
);
return STATUS_DATA_OVERRUN;
}
if ( ( StatusRegister1 & STREG1_SECTOR_NOT_FOUND ) ||
( StatusRegister1 & STREG1_END_OF_DISKETTE ) ) {
FloppyDump(
FLOPSHOW,
("FlInterpretError: STATUS_NONEXISTENT_SECTOR\n")
);
return STATUS_NONEXISTENT_SECTOR;
}
if ( ( StatusRegister2 & STREG2_DATA_NOT_FOUND ) ||
( StatusRegister2 & STREG2_BAD_CYLINDER ) ||
( StatusRegister2 & STREG2_DELETED_DATA ) ) {
FloppyDump(
FLOPSHOW,
("FlInterpretError: STATUS_DEVICE_DATA_ERROR\n")
);
return STATUS_DEVICE_DATA_ERROR;
}
if ( StatusRegister1 & STREG1_WRITE_PROTECTED ) {
FloppyDump(
FLOPSHOW,
("FlInterpretError: STATUS_MEDIA_WRITE_PROTECTED\n")
);
return STATUS_MEDIA_WRITE_PROTECTED;
}
if ( StatusRegister1 & STREG1_ID_NOT_FOUND ) {
FloppyDump(
FLOPSHOW,
("FlInterpretError: STATUS_FLOPPY_ID_MARK_NOT_FOUND\n")
);
return STATUS_FLOPPY_ID_MARK_NOT_FOUND;
}
if ( StatusRegister2 & STREG2_WRONG_CYLINDER ) {
FloppyDump(
FLOPSHOW,
("FlInterpretError: STATUS_FLOPPY_WRONG_CYLINDER\n")
);
return STATUS_FLOPPY_WRONG_CYLINDER;
}
//
// There's other error bits, but no good status values to map them
// to. Just return a generic one.
//
FloppyDump(
FLOPSHOW,
("FlInterpretError: STATUS_FLOPPY_UNKNOWN_ERROR\n")
);
return STATUS_FLOPPY_UNKNOWN_ERROR;
}
BOOLEAN
FlClearIsrReentered(
IN PVOID Context
)
/*++
Routine Description:
This routine is simply used to clear the reentered count of the isr.
Arguments:
Context - Simply a pointer to the re-entered count of the isr.
Return Value:
Always False.
--*/
{
*((ULONG *)Context) = 0;
return FALSE;
}
VOID
FlFinishOperation(
IN OUT PIRP Irp,
IN PDISKETTE_EXTENSION DisketteExtension
)
/*++
Routine Description:
This routine is called by FloppyThread at the end of any operation
whether it succeeded or not.
If the packet is failing due to a hardware error, this routine will
reinitialize the hardware and retry once.
When the packet is done, this routine will start the timer to turn
off the motor, and complete the IRP.
Arguments:
Irp - a pointer to the IO Request Packet being processed.
DisketteExtension - a pointer to the diskette extension for the
diskette on which the operation occurred.
Return Value:
None.
--*/
{
PCONTROLLER_DATA controllerData;
NTSTATUS ntStatus;
FloppyDump(
FLOPSHOW,
("Floppy: FloppyFinishOperation...\n")
);
controllerData = DisketteExtension->ControllerData;
//
// See if this packet is being failed due to a hardware error.
//
if ( ( Irp->IoStatus.Status != STATUS_SUCCESS ) &&
( controllerData->HardwareFailed ) ) {
controllerData->HardwareFailCount++;
if ( controllerData->HardwareFailCount < HARDWARE_RESET_RETRY_COUNT ) {
KeSynchronizeExecution(
controllerData->InterruptObject,
FlClearIsrReentered,
&controllerData->IsrReentered
);
//
// This is our first time through (that is, we're not retrying
// the packet after a hardware failure). If it failed this first
// time because of a hardware problem, set the HardwareFailed flag
// and put the IRP at the beginning of the request queue.
//
ntStatus = FlInitializeControllerHardware(
controllerData,
DisketteExtension->DeviceObject );
if ( NT_SUCCESS( ntStatus ) ) {
FloppyDump(
FLOPINFO,
("Floppy: packet failed; hardware reset. Retry.\n")
);
//
// Force media to be redetermined, in case we messed up
// and to make sure FlDatarateSpecifyConfigure() gets
// called.
//
DisketteExtension->MediaType = Undetermined;
FloppyDump(
FLOPIRPPATH,
("Floppy: irp %x failed - back on the queue with it\n",
Irp)
);
ExAcquireFastMutex(&controllerData->ThreadReferenceMutex);
ASSERT(controllerData->ThreadReferenceCount >= 0);
(controllerData->ThreadReferenceCount)++;
ExReleaseFastMutex(&controllerData->ThreadReferenceMutex);
ExInterlockedInsertHeadList(
&controllerData->ListEntry,
&Irp->Tail.Overlay.ListEntry,
&controllerData->ListSpinLock );
return;
}
FloppyDump(
FLOPDBGP,
("Floppy: packet AND hardware reset failed.\n")
);
}
}
//
// If we didn't already RETURN, we're done with this packet so
// reset the HardwareFailCount for the next packet.
//
controllerData->HardwareFailCount = 0;
//
// If this request was unsuccessful and the error is one that can be
// remedied by the user, save the Device Object so that the file system,
// after reaching its original entry point, can know the real device.
//
if ( !NT_SUCCESS( Irp->IoStatus.Status ) &&
IoIsErrorUserInduced( Irp->IoStatus.Status ) ) {
IoSetHardErrorOrVerifyDevice( Irp, DisketteExtension->DeviceObject );
}
//
// Even if the operation failed, it probably had to wait for the drive
// to spin up or somesuch so we'll always complete the request with the
// standard priority boost.
//
if ( ( Irp->IoStatus.Status != STATUS_SUCCESS ) &&
( Irp->IoStatus.Status != STATUS_VERIFY_REQUIRED ) &&
( Irp->IoStatus.Status != STATUS_NO_MEDIA_IN_DEVICE ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: IRP failed with error %lx\n", Irp->IoStatus.Status)
);
} else {
FloppyDump(
FLOPINFO,
("Floppy: IoStatus.Status = %x\n", Irp->IoStatus.Status)
);
}
FloppyDump(
FLOPINFO,
("Floppy: IoStatus.Information = %x\n", Irp->IoStatus.Information)
);
FloppyDump(
FLOPIRPPATH,
("Floppy: Finishing up IRP: %x\n",Irp)
);
IoCompleteRequest( Irp, IO_DISK_INCREMENT );
}
VOID
FlTurnOffMotor(
IN OUT PCONTROLLER_DATA ControllerData
)
/*++
Routine Description:
This routine turns off the motor.
Arguments:
DisketteExtension - Supplies the diskette extension.
Return Value:
None.
--*/
{
ControllerData->DriveControlImage =
DRVCTL_ENABLE_DMA_AND_INTERRUPTS +
#ifdef _PPC_
DRVCTL_DRIVE_MASK +
#endif
DRVCTL_ENABLE_CONTROLLER;
WRITE_CONTROLLER(
&ControllerData->ControllerAddress->DriveControl,
ControllerData->DriveControlImage );
if (ControllerData->CurrentInterrupt) {
ControllerData->CurrentInterrupt = FALSE;
KeSetEvent(ControllerData->ControllerEvent,
(KPRIORITY) 0,
FALSE);
}
FlFreeIoBuffer(ControllerData);
}
NTSTATUS
FlIssueCommand(
IN UCHAR Command,
IN OUT PDISKETTE_EXTENSION DisketteExtension
)
/*++
Routine Description:
This routine sends the command and all parameters to the controller,
waits for the command to interrupt if necessary, and reads the result
bytes from the controller, if any.
Before calling this routine, the caller should put the parameters for
the command in ControllerData->FifoBuffer[]. The result bytes will
be returned in the same place.
This routine runs off the CommandTable. For each command, this says
how many parameters there are, whether or not there is an interrupt
to wait for, and how many result bytes there are. Note that commands
without result bytes actually have two, since the ISR will issue a
SENSE INTERRUPT STATUS command on their behalf.
Arguments:
Command - a byte specifying the command to be sent to the controller.
DisketteExtension - a pointer to our data area for the drive being
accessed (any drive if a controller command is being given).
Return Value:
STATUS_SUCCESS if the command was sent and bytes received properly;
appropriate error propogated otherwise.
--*/
{
PCONTROLLER_DATA controllerData;
NTSTATUS ntStatus;
NTSTATUS ntStatus2;
UCHAR i;
FloppyDump(
FLOPSHOW,
("Floppy: FloppyIssueCommand %2x...\n", Command)
);
controllerData = DisketteExtension->ControllerData;
//
// If this command causes an interrupt, set CurrentDeviceObject and
// reset the interrupt event.
//
if ( CommandTable[Command & COMMAND_MASK].InterruptExpected ) {
controllerData->CurrentDeviceObject = DisketteExtension->DeviceObject;
controllerData->AllowInterruptProcessing = TRUE;
controllerData->CommandHasResultPhase =
!!CommandTable[Command & COMMAND_MASK].FirstResultByte;
KeResetEvent( &controllerData->InterruptEvent );
}
#if defined(DBCS) && defined(_MIPS_)
//
// Call FlOutputCommandFor3Mode(), so the drive mode can be changed
// if necessary.
//
ntStatus = FlOutputCommandFor3Mode( Command, DisketteExtension );
if (!NT_SUCCESS( ntStatus )) {
return ntStatus;
}
#endif // DBCS && _MIPS_
//
// Send the command to the controller.
//
ntStatus = FlSendByte( Command, controllerData );
//
// If the command was successfully sent, we can proceed.
//
if ( NT_SUCCESS( ntStatus ) ) {
//
// Send the parameters as long as we succeed.
//
for ( i = 0;
( i < CommandTable[Command & COMMAND_MASK].NumberOfParameters ) &&
( NT_SUCCESS( ntStatus ) );
i++ ) {
ntStatus = FlSendByte(
controllerData->FifoBuffer[i],
controllerData );
}
if ( NT_SUCCESS( ntStatus ) ) {
//
// If there is an interrupt, wait for it.
//
if ( CommandTable[Command & COMMAND_MASK].InterruptExpected ) {
ntStatus = KeWaitForSingleObject(
&controllerData->InterruptEvent,
Executive,
KernelMode,
FALSE,
&controllerData->InterruptDelay );
if ( ntStatus == STATUS_TIMEOUT ) {
//
// Change info to an error. We'll just say
// that the device isn't ready.
//
ntStatus = STATUS_DEVICE_NOT_READY;
controllerData->HardwareFailed = TRUE;
}
#ifdef KEEP_COUNTERS
FloppyThreadTime = KeQueryPerformanceCounter((PVOID)NULL);
FloppyThreadTime.QuadPart = FloppyThreadDelay.QuadPart +
(FloppyThreadTime.QuadPart -
FloppyDPCTime.QuadPart);
FloppyFromIntrDelay.QuadPart = FloppyFromIntrDelay.QuadPart +
(FloppyThreadTime.QuadPart -
FloppyIntrTime.QuadPart);
FloppyThreadWake++;
#endif
}
//
// If successful so far, get the result bytes.
//
if ( NT_SUCCESS( ntStatus ) ) {
for ( i = CommandTable[Command & COMMAND_MASK].FirstResultByte;
( i < CommandTable[Command & COMMAND_MASK].
NumberOfResultBytes ) && ( NT_SUCCESS( ntStatus ) );
i++ ) {
ntStatus = FlGetByte(
&controllerData->FifoBuffer[i],
controllerData );
}
} else {
FloppyDump(
FLOPINFO,
("FlIssueCommand: failure after issue %x\n", ntStatus)
);
}
}
}
//
// If there was a problem, check to see if it was caused by an
// unimplemented command.
//
if ( !NT_SUCCESS( ntStatus ) ) {
if ( ( i == 1 ) &&
( !CommandTable[Command & COMMAND_MASK].AlwaysImplemented ) ) {
//
// This error is probably caused by a command that's not
// implemented on this controller. Read the error from the
// controller, and we should be in a stable state.
//
ntStatus2 = FlGetByte(
&controllerData->FifoBuffer[0],
controllerData );
//
// If GetByte went as planned, we'll return the original error.
//
if ( NT_SUCCESS( ntStatus2 ) ) {
if ( controllerData->FifoBuffer[0] !=
STREG0_END_INVALID_COMMAND ) {
//
// Status isn't as we expect, so return generic error.
//
ntStatus = STATUS_FLOPPY_BAD_REGISTERS;
controllerData->HardwareFailed = TRUE;
FloppyDump(
FLOPINFO,
("FlIssueCommand: unexpected error value %2x\n",
controllerData->FifoBuffer[0])
);
} else {
FloppyDump(
FLOPINFO,
("FlIssueCommand: Invalid command error returned\n")
);
}
} else {
//
// GetByte returned an error, so propogate THAT.
//
FloppyDump(
FLOPINFO,
("FlIssueCommand: FlGetByte returned error %x\n", ntStatus2)
);
ntStatus = ntStatus2;
}
}
}
if ( !NT_SUCCESS( ntStatus ) ) {
//
// Print an error message unless the command isn't always
// implemented, ie CONFIGURE.
//
if ( !( ( ntStatus == STATUS_DEVICE_NOT_READY ) &&
( !CommandTable[Command & COMMAND_MASK].AlwaysImplemented ) ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: err %x "
"------ while giving command %x\n",
ntStatus,
Command)
);
}
}
return ntStatus;
}
NTSTATUS
FlTurnOnMotor(
IN OUT PDISKETTE_EXTENSION DisketteExtension,
IN BOOLEAN WriteOperation,
OUT PBOOLEAN MotorStarted
)
/*++
Routine Description:
This routine turns on the motor if it not already running.
Arguments:
DisketteExtension - Supplies the diskette extension.
WriteOperation - Supplies whether or not the diskette will be written
to.
MotorStarted - Returns whether or not the motor was started.
Return Value:
STATUS_DEVICE_BUSY if we don't have the controller, otherwise
STATUS_SUCCESS
--*/
{
UCHAR driveStatus;
NTSTATUS waitStatus;
LARGE_INTEGER controllerWait;
PCONTROLLER_DATA controllerData;
USHORT timeToWait;
LARGE_INTEGER motorOnDelay;
*MotorStarted = FALSE;
controllerData = DisketteExtension->ControllerData;
driveStatus = controllerData->DriveControlImage;
if ( driveStatus != DisketteExtension->DriveOnValue ) {
// If the drive is not on then check to see if we have
// the controller. Otherwise we assume that we have
// the controller since we give it up only when we
// turn off the motor.
if (!controllerData->CurrentInterrupt) {
controllerWait.QuadPart = -(10 * 1000 * 3000);
waitStatus = KeWaitForSingleObject(
controllerData->ControllerEvent,
Executive,
UserMode,
FALSE,
&controllerWait);
if (waitStatus == STATUS_TIMEOUT) {
return STATUS_DEVICE_BUSY;
}
controllerData->CurrentInterrupt = TRUE;
driveStatus = controllerData->DriveControlImage;
}
controllerData->AllowInterruptProcessing = TRUE;
controllerData->DriveControlImage = DisketteExtension->DriveOnValue;
WRITE_CONTROLLER(
&controllerData->ControllerAddress->DriveControl,
controllerData->DriveControlImage );
//
// If this the drive media is unknown, initialize the diskette
// extension. This is done to get the time to wait value so use
// the slowest and oldest drive type.
//
if ((DisketteExtension->MediaType == Undetermined) ||
(DisketteExtension->MediaType == Unknown)) {
DisketteExtension->DriveMediaConstants = DriveMediaConstants[0];
}
//
// Wait the appropriate length of time for the drive to spin up.
//
if ( WriteOperation ) {
timeToWait = DisketteExtension->DriveMediaConstants.MotorSettleTimeWrite;
} else {
timeToWait = DisketteExtension->DriveMediaConstants.MotorSettleTimeRead;
}
FloppyDump(
FLOPSHOW,
("Floppy: Waiting for motor to spin up (0x%x)...\n", timeToWait)
);
motorOnDelay.LowPart = - ( 10 * 1000 * timeToWait );
motorOnDelay.HighPart = -1;
KeDelayExecutionThread( KernelMode, FALSE, &motorOnDelay );
*MotorStarted = TRUE;
}
return STATUS_SUCCESS;
}
BOOLEAN
FlDisketteRemoved(
IN PCONTROLLER_DATA ControllerData,
IN UCHAR DriveStatus,
IN BOOLEAN MotorStarted
)
/*++
Routine Description:
This routine computes whether or not the diskette has been
removed from the drive by examining the disk change bit in
the given drive status byte. It is now assumed that if the
motor has just been started this will return that the diskette
changed.
Arguments:
ControllerData - Supplies the controller data.
DriveStatus - Supplies the drive status.
Return Value:
TRUE - The diskette has been removed.
--*/
{
UCHAR invertMask;
#if 0
if (MotorStarted) {
return TRUE;
}
#endif
invertMask = ControllerData->Model30 ? DSKCHG_DISKETTE_REMOVED : 0;
return (DriveStatus ^ invertMask) & DSKCHG_DISKETTE_REMOVED;
}
NTSTATUS
FlStartDrive(
IN OUT PDISKETTE_EXTENSION DisketteExtension,
IN PIRP Irp,
IN BOOLEAN WriteOperation,
IN BOOLEAN SetUpMedia,
IN BOOLEAN IgnoreChange
)
/*++
Routine Description:
This routine is called at the beginning of every operation. It cancels
the motor timer if it's on, turns the motor on and waits for it to
spin up if it was off, resets the disk change line and returns
VERIFY_REQUIRED if the disk has been changed, determines the diskette
media type if it's not known and SetUpMedia=TRUE, and makes sure that
the disk isn't write protected if WriteOperation = TRUE.
Arguments:
DisketteExtension - a pointer to our data area for the drive being
started.
Irp - Supplies the I/O request packet.
WriteOperation - TRUE if the diskette will be written to, FALSE
otherwise.
SetUpMedia - TRUE if the media type of the diskette in the drive
should be determined.
IgnoreChange - Do not return VERIFY_REQUIRED eventhough we are mounting
for the first time.
Return Value:
STATUS_SUCCESS if the drive is started properly; appropriate error
propogated otherwise.
--*/
{
LARGE_INTEGER delay;
PCONTROLLER_DATA controllerData;
BOOLEAN motorStarted;
UCHAR driveStatus;
NTSTATUS ntStatus = STATUS_SUCCESS;
FloppyDump(
FLOPSHOW,
("Floppy: FloppyStartDrive...\n")
);
//
// IMPORTANT
// NOTE
// COMMENT
//
// Here we will copy the BIOS floppy configuration on top of the
// highest media value in our global array so that any type of processing
// that will recalibrate the drive can have it done here.
// An optimization would be to only do it when we will try to recalibrate
// the driver or media in it.
// At this point, we ensure that on any processing of a command we
// are going to have the real values inthe first entry of the array for
// driver constants.
//
DriveMediaConstants[DriveMediaLimits[DisketteExtension->DriveType].
HighestDriveMediaType] = DisketteExtension->BiosDriveMediaConstants;
controllerData = DisketteExtension->ControllerData;
//
// Grab the timer spin lock and cancel the timer, since we want the
// motor to run for the whole operation. If the proper drive is
// already running, great; if not, start the motor and wait for it
// to spin up.
//
ntStatus = FlTurnOnMotor(DisketteExtension, WriteOperation, &motorStarted);
if (!NT_SUCCESS(ntStatus)) {
return ntStatus;
}
driveStatus = READ_CONTROLLER(
&controllerData->ControllerAddress->DRDC.DiskChange );
//
// Support for 360K drives:
// They have no change line, so we will assume a power up of the motor
// to be equivalent to a change of floppy (we assume noone will
// change the floppy while it is turning.
// So force a VERIFY here (unless the file system explicitly turned
// it off).
//
if ( ((DisketteExtension->DriveType == DRIVE_TYPE_0360) &&
motorStarted) ||
((DisketteExtension->DriveType != DRIVE_TYPE_0360) &&
FlDisketteRemoved(controllerData, driveStatus, motorStarted)) ) {
FloppyDump(
FLOPSHOW,
("Floppy: disk changed...\n")
);
DisketteExtension->MediaType = Undetermined;
//
// If the volume is mounted, we must tell the filesystem to
// verify that the media in the drive is the same volume.
//
if ( DisketteExtension->DeviceObject->Vpb->Flags & VPB_MOUNTED ) {
if (Irp) {
IoSetHardErrorOrVerifyDevice( Irp, DisketteExtension->DeviceObject );
}
DisketteExtension->DeviceObject->Flags |= DO_VERIFY_VOLUME;
}
//
// Only go through the device reset if we did get the flag set
// We really only want to go throught here if the diskette changed,
// but on 360 it will always say the diskette has changed.
// So based on our previous test, only proceed if it is NOT
// a 360K driver
if (DisketteExtension->DriveType != DRIVE_TYPE_0360) {
//
// Now seek twice to reset the "disk changed" line. First
// seek to 1.
//
// Normally we'd do a READ ID after a seek. However, we don't
// even know if this disk is formatted. We're not really
// trying to get anywhere; we're just doing this to reset the
// "disk changed" line so we'll skip the READ ID.
//
controllerData->FifoBuffer[0] = DisketteExtension->DeviceUnit;
controllerData->FifoBuffer[1] = 1;
ntStatus = FlIssueCommand( COMMND_SEEK, DisketteExtension );
if ( !NT_SUCCESS( ntStatus ) ) {
FloppyDump(
FLOPWARN,
("Floppy: seek to 1 returned %x\n", ntStatus)
);
return ntStatus;
} else {
if ( !( controllerData->FifoBuffer[0] & STREG0_SEEK_COMPLETE )
|| ( controllerData->FifoBuffer[1] != 1 ) ) {
FloppyDump(
FLOPWARN,
("Floppy: Seek to 1 had bad return registers\n")
);
controllerData->HardwareFailed = TRUE;
return STATUS_FLOPPY_BAD_REGISTERS;
}
}
//
// Seek back to 0. We can once again skip the READ ID.
//
controllerData->FifoBuffer[0] = DisketteExtension->DeviceUnit;
controllerData->FifoBuffer[1] = 0;
//
// Floppy drives use by Toshiba systems require a delay
// when this operation is performed.
//
delay.LowPart = (ULONG) -900;
delay.HighPart = -1;
KeDelayExecutionThread( KernelMode, FALSE, &delay );
ntStatus = FlIssueCommand( COMMND_SEEK, DisketteExtension );
//
// Again, for Toshiba floppy drives, a delay is required.
//
delay.LowPart = (ULONG) -5;
delay.HighPart = -1;
KeDelayExecutionThread( KernelMode, FALSE, &delay );
if ( !NT_SUCCESS( ntStatus ) ) {
FloppyDump(
FLOPWARN,
("Floppy: seek to 0 returned %x\n", ntStatus)
);
return ntStatus;
} else {
if ( !( controllerData->FifoBuffer[0] & STREG0_SEEK_COMPLETE )
|| ( controllerData->FifoBuffer[1] != 0 ) ) {
FloppyDump(
FLOPWARN,
("Floppy: Seek to 0 had bad return registers\n")
);
controllerData->HardwareFailed = TRUE;
return STATUS_FLOPPY_BAD_REGISTERS;
}
}
driveStatus = READ_CONTROLLER(
&controllerData->ControllerAddress->DRDC.DiskChange );
if ( FlDisketteRemoved(controllerData, driveStatus, motorStarted) ) {
//
// If "disk changed" is still set after the double seek, the
// drive door must be opened.
//
FloppyDump(
FLOPINFO,
("Floppy: close the door!\n")
);
//
// Turn off the flag for now so that we will not get so many
// gratuitous verifys. It will be set again the next time.
//
if ( DisketteExtension->DeviceObject->Vpb->Flags & VPB_MOUNTED ) {
DisketteExtension->DeviceObject->Flags &= ~DO_VERIFY_VOLUME;
}
return STATUS_NO_MEDIA_IN_DEVICE;
}
}
//
// IgnoreChange indicates the file system is in the process
// of performing a verify so do not return verify required.
//
if (( IgnoreChange == FALSE ) &&
( DisketteExtension->DeviceObject->Vpb->Flags & VPB_MOUNTED )) {
//
// Drive WAS mounted, but door was opened since the last time
// we checked so tell the file system to verify the diskette.
//
FloppyDump(
FLOPSHOW,
("Floppy: start drive - verify required because door opened\n")
);
return STATUS_VERIFY_REQUIRED;
}
}
if ( SetUpMedia ) {
if ( DisketteExtension->MediaType == Undetermined ) {
ntStatus = FlDetermineMediaType( DisketteExtension );
} else {
if ( DisketteExtension->MediaType == Unknown ) {
//
// We've already tried to determine the media type and
// failed. It's probably not formatted.
//
FloppyDump(
FLOPSHOW,
("Floppy - start drive - media type was unknown\n")
);
return STATUS_UNRECOGNIZED_MEDIA;
} else {
if ( DisketteExtension->DriveMediaType !=
controllerData->LastDriveMediaType ) {
//
// Last drive/media combination accessed by the
// controller was different, so set up the controller.
//
ntStatus = FlDatarateSpecifyConfigure( DisketteExtension );
if (!NT_SUCCESS(ntStatus)) {
FloppyDump(
FLOPWARN,
("Floppy: start drive - bad status from datarate"
"------ specify %x\n",
ntStatus)
);
}
}
}
}
}
//
// If this is a WRITE, check the drive to make sure it's not write
// protected. If so, return an error.
//
if ( ( WriteOperation ) && ( NT_SUCCESS( ntStatus ) ) ) {
controllerData->FifoBuffer[0] = DisketteExtension->DeviceUnit;
ntStatus = FlIssueCommand( COMMND_SENSE_DRIVE, DisketteExtension );
if ( !NT_SUCCESS( ntStatus ) ) {
FloppyDump(
FLOPWARN,
("Floppy: SENSE_DRIVE returned %x\n", ntStatus)
);
return ntStatus;
}
if ( controllerData->FifoBuffer[0] & STREG3_WRITE_PROTECTED ) {
FloppyDump(
FLOPSHOW,
("Floppy: start drive - media is write protected\n")
);
return STATUS_MEDIA_WRITE_PROTECTED;
}
}
return ntStatus;
}
NTSTATUS
FlDatarateSpecifyConfigure(
IN PDISKETTE_EXTENSION DisketteExtension
)
/*++
Routine Description:
This routine is called to set up the controller every time a new type
of diskette is to be accessed. It issues the CONFIGURE command if
it's available, does a SPECIFY, sets the data rate, and RECALIBRATEs
the drive.
The caller must set DisketteExtension->DriveMediaType before calling
this routine.
Arguments:
DisketteExtension - pointer to our data area for the drive to be
prepared.
Return Value:
STATUS_SUCCESS if the controller is properly prepared; appropriate
error propogated otherwise.
--*/
{
PCONTROLLER_DATA controllerData;
NTSTATUS ntStatus = STATUS_SUCCESS;
controllerData = DisketteExtension->ControllerData;
FloppyDump(
FLOPSHOW,
("Floppy: FloppyDatarateSpecifyConfigure: Controller is %s configurable\n",
controllerData->ControllerConfigurable ? "" : "not")
);
//
// If the controller has a CONFIGURE command, use it to enable implied
// seeks. If it doesn't, we'll find out here the first time through.
//
if ( controllerData->ControllerConfigurable ) {
controllerData->FifoBuffer[0] = 0;
controllerData->FifoBuffer[1] = COMMND_CONFIGURE_FIFO_THRESHOLD;
controllerData->FifoBuffer[1] += COMMND_CONFIGURE_DISABLE_POLLING;
if (!DisketteExtension->DriveMediaConstants.CylinderShift) {
controllerData->FifoBuffer[1] += COMMND_CONFIGURE_IMPLIED_SEEKS;
}
controllerData->FifoBuffer[2] = 0;
ntStatus = FlIssueCommand( COMMND_CONFIGURE, DisketteExtension );
if ( ntStatus == STATUS_DEVICE_NOT_READY ) {
//
// Note the CONFIGURE command doesn't exist. Set status to
// success, so we can issue the SPECIFY command below.
//
FloppyDump(
FLOPINFO,
("Floppy: Ignore above error - no CONFIGURE command\n")
);
controllerData->ControllerConfigurable = FALSE;
ntStatus = STATUS_SUCCESS;
}
}
//
// Issue SPECIFY command to program the head load and unload
// rates, the drive step rate, and the DMA data transfer mode.
//
if ( NT_SUCCESS( ntStatus ) ) {
controllerData->FifoBuffer[0] =
DisketteExtension->DriveMediaConstants.StepRateHeadUnloadTime;
controllerData->FifoBuffer[1] =
DisketteExtension->DriveMediaConstants.HeadLoadTime;
ntStatus = FlIssueCommand( COMMND_SPECIFY, DisketteExtension );
if ( NT_SUCCESS( ntStatus ) ) {
//
// Program the data rate
//
WRITE_CONTROLLER(
&controllerData->ControllerAddress->DRDC.DataRate,
DisketteExtension->DriveMediaConstants.DataTransferRate );
//
// Recalibrate the drive, now that we've changed all its
// parameters.
//
ntStatus = FlRecalibrateDrive( DisketteExtension );
} else {
FloppyDump(
FLOPINFO,
("Floppy: Failed specify %x\n", ntStatus)
);
}
} else {
FloppyDump(
FLOPINFO,
("Floppy: Failed configuration %x\n", ntStatus)
);
}
if ( NT_SUCCESS( ntStatus ) ) {
controllerData->LastDriveMediaType = DisketteExtension->DriveMediaType;
} else {
controllerData->LastDriveMediaType = Unknown;
FloppyDump(
FLOPINFO,
("Floppy: Failed recalibrate %x\n", ntStatus)
);
}
return ntStatus;
}
NTSTATUS
FlRecalibrateDrive(
IN PDISKETTE_EXTENSION DisketteExtension
)
/*++
Routine Description:
This routine recalibrates a drive. It is called whenever we're
setting up to access a new diskette, and after certain errors. It
will actually recalibrate twice, since many controllers stop after
77 steps and many disks have 80 tracks.
Arguments:
DisketteExtension - pointer to our data area for the drive to be
recalibrated.
Return Value:
STATUS_SUCCESS if the drive is successfully recalibrated; appropriate
error is propogated otherwise.
--*/
{
PCONTROLLER_DATA controllerData;
NTSTATUS ntStatus;
UCHAR recalibrateCount;
controllerData = DisketteExtension->ControllerData;
recalibrateCount = 0;
do {
//
// Issue the recalibrate command
//
controllerData->FifoBuffer[0] = DisketteExtension->DeviceUnit;
ntStatus = FlIssueCommand( COMMND_RECALIBRATE, DisketteExtension );
if ( !NT_SUCCESS( ntStatus ) ) {
FloppyDump(
FLOPWARN,
("Floppy: recalibrate returned %x\n", ntStatus)
);
}
if ( NT_SUCCESS( ntStatus ) ) {
if ( !( controllerData->FifoBuffer[0] & STREG0_SEEK_COMPLETE ) ||
( controllerData->FifoBuffer[1] != 0 ) ) {
FloppyDump(
FLOPWARN,
("Floppy: recalibrate had bad registers\n")
);
controllerData->HardwareFailed = TRUE;
ntStatus = STATUS_FLOPPY_BAD_REGISTERS;
}
}
recalibrateCount++;
} while ( ( !NT_SUCCESS( ntStatus ) ) && ( recalibrateCount < 2 ) );
FloppyDump(
FLOPSHOW,
("Floppy: FloppyRecalibrateDrive: status %x, count %d\n", ntStatus, recalibrateCount)
);
return ntStatus;
}
NTSTATUS
FlDetermineMediaType(
IN OUT PDISKETTE_EXTENSION DisketteExtension
)
/*++
Routine Description:
This routine is called by FlStartDrive() when the media type is
unknown. It assumes the largest media supported by the drive is
available, and keeps trying lower values until it finds one that
works.
Arguments:
DisketteExtension - pointer to our data area for the drive whose
media is to checked.
Return Value:
STATUS_SUCCESS if the type of the media is determined; appropriate
error propogated otherwise.
--*/
{
NTSTATUS ntStatus;
PCONTROLLER_DATA controllerData;
PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
BOOLEAN mediaTypesExhausted = FALSE;
ULONG retries = 0;
FloppyDump(
FLOPSHOW,
("FlDetermineMediaType...\n")
);
controllerData = DisketteExtension->ControllerData;
DisketteExtension->IsReadOnly = FALSE;
//
// Try up to three times for read the media id.
//
for (
retries = 0;
retries < 3;
retries++
) {
if (retries) {
//
// We're retrying the media determination because
// some silly controllers don't always want to work
// at setup. First we'll reset the device to give
// it a better chance of working.
//
FloppyDump(
FLOPINFO,
("FlDetermineMediaType: Resetting controller\n")
);
FlInitializeControllerHardware(
controllerData,
DisketteExtension->DeviceObject
);
}
//
// Assume that the largest supported media is in the drive. If that
// turns out to be untrue, we'll try successively smaller media types
// until we find what's really in there (or we run out and decide
// that the media isn't formatted).
//
DisketteExtension->DriveMediaType =
DriveMediaLimits[DisketteExtension->DriveType].HighestDriveMediaType;
DisketteExtension->DriveMediaConstants =
DriveMediaConstants[DisketteExtension->DriveMediaType];
do {
ntStatus = FlDatarateSpecifyConfigure( DisketteExtension );
if ( !NT_SUCCESS( ntStatus ) ) {
//
// The SPECIFY or CONFIGURE commands resulted in an error.
// Force ourselves out of this loop and return error.
//
FloppyDump(
FLOPINFO,
("FlDetermineMediaType: DatarateSpecify failed %x\n", ntStatus)
);
mediaTypesExhausted = TRUE;
} else {
//
// Use the media constants table when trying to determine
// media type.
//
driveMediaConstants =
&DriveMediaConstants[DisketteExtension->DriveMediaType];
//
// Now try to read the ID from wherever we're at.
//
controllerData->FifoBuffer[0] = (UCHAR)
( DisketteExtension->DeviceUnit |
( ( driveMediaConstants->NumberOfHeads - 1 ) << 2 ) );
ntStatus = FlIssueCommand(
COMMND_READ_ID + COMMND_MFM,
DisketteExtension );
if ( ( !NT_SUCCESS( ntStatus ) ) ||
( (controllerData->FifoBuffer[0]&(~STREG0_SEEK_COMPLETE)) !=
(UCHAR)( ( DisketteExtension->DeviceUnit ) |
( ( driveMediaConstants->NumberOfHeads - 1 ) << 2 ) ) ) ||
( controllerData->FifoBuffer[1] != 0 ) ||
#if defined(DBCS) && defined(_MIPS_)
( controllerData->FifoBuffer[2] != 0 ) ||
( (128 << (controllerData->FifoBuffer[6])) != driveMediaConstants->BytesPerSector )
#else // !DBCS && !_MIPS_
( controllerData->FifoBuffer[2] != 0 )
#endif // DBCS && _MIPS_
) {
FloppyDump(
FLOPINFO,
("Floppy: READID failed trying lower media\n"
"------ status = %x\n"
"------ SR0 = %x\n"
"------ SR1 = %x\n"
"------ SR2 = %x\n",
ntStatus,
controllerData->FifoBuffer[0],
controllerData->FifoBuffer[1],
controllerData->FifoBuffer[2])
);
DisketteExtension->DriveMediaType--;
#if defined(DBCS) && defined(_MIPS_)
//
// This drive isn't the 3 mode Floppy disk drive.
// So the driver skips over 1.23Mb and 1.2MB format
// when it determines a DriveMediaType for DRIVE_TYPE_1440.
//
if (( DisketteExtension->DriveType == DRIVE_TYPE_1440 ) &&
( DisketteExtension->DriveMediaType == Drive144Media123) &&
( DisketteExtension->Drive3Mode == DRIVE_2MODE )) {
FloppyDump(
FLOPINFO,
("Floppy: Skip over 1.23Mb and 1.2Mb\n")
);
DisketteExtension->DriveMediaType = Drive144Media720;
}
#endif // DBCS && _MIPS_
DisketteExtension->DriveMediaConstants =
DriveMediaConstants[DisketteExtension->DriveMediaType];
if (ntStatus != STATUS_DEVICE_NOT_READY) {
ntStatus = STATUS_UNRECOGNIZED_MEDIA;
}
//
// Next comparison must be signed, for when
// LowestDriveMediaType = 0.
//
if ( (CHAR)( DisketteExtension->DriveMediaType ) <
(CHAR)( DriveMediaLimits[DisketteExtension->DriveType].
LowestDriveMediaType ) ) {
DisketteExtension->MediaType = Unknown;
mediaTypesExhausted = TRUE;
FloppyDump(
FLOPINFO,
("Floppy: Unrecognized media.\n")
);
}
}
}
} while ( ( !NT_SUCCESS( ntStatus ) ) && !( mediaTypesExhausted ) );
if (NT_SUCCESS(ntStatus)) {
//
// We determined the media type. Time to move on.
//
FloppyDump(
FLOPINFO,
("Floppy: Determined media type %d\n", retries)
);
break;
}
}
if ( (!NT_SUCCESS( ntStatus )) || mediaTypesExhausted) {
FloppyDump(
FLOPINFO,
("Floppy: failed determine types status = %x %s\n",
ntStatus,
mediaTypesExhausted ? "media types exhausted" : "")
);
return ntStatus;
}
DisketteExtension->MediaType = driveMediaConstants->MediaType;
DisketteExtension->BytesPerSector = driveMediaConstants->BytesPerSector;
DisketteExtension->ByteCapacity =
( driveMediaConstants->BytesPerSector ) *
driveMediaConstants->SectorsPerTrack *
( 1 + driveMediaConstants->MaximumTrack ) *
driveMediaConstants->NumberOfHeads;
FloppyDump(
FLOPINFO,
("FlDetermineMediaType: MediaType is %x, bytes per sector %d, capacity %d\n",
DisketteExtension->MediaType,
DisketteExtension->BytesPerSector,
DisketteExtension->ByteCapacity)
);
//
// Structure copy the media constants into the diskette extension.
//
DisketteExtension->DriveMediaConstants =
DriveMediaConstants[DisketteExtension->DriveMediaType];
//
// Check the boot sector for any overriding geometry information.
//
FlCheckBootSector(DisketteExtension);
return ntStatus;
}
VOID
FlAllocateAdapterChannel(
IN OUT PDISKETTE_EXTENSION DisketteExtension
)
/*++
Routine Description:
This routine allocates an adapter channel. The caller of this
routine must wait for the 'AllocateAdapterChannelEvent' to be signalled
before trying to use the adapter channel.
Arguments:
DisketteExtension - Supplies the diskette extension.
Return Value:
None.
--*/
{
KIRQL oldIrql;
PCONTROLLER_DATA controllerData = DisketteExtension->ControllerData;
if ((controllerData->AdapterChannelRefCount)++) {
return;
}
KeResetEvent(&controllerData->AllocateAdapterChannelEvent);
KeRaiseIrql( DISPATCH_LEVEL, &oldIrql );
IoAllocateAdapterChannel(
controllerData->AdapterObject,
DisketteExtension->DeviceObject,
controllerData->NumberOfMapRegisters,
FloppyAllocateAdapterChannel,
controllerData );
KeLowerIrql( oldIrql );
KeWaitForSingleObject(&controllerData->AllocateAdapterChannelEvent,
Executive, KernelMode, FALSE, NULL);
}
VOID
FlFreeAdapterChannel(
IN OUT PDISKETTE_EXTENSION DisketteExtension
)
/*++
Routine Description:
This routine frees the previously allocated adapter channel.
Arguments:
DisketteExtension - Supplies the diskette extension.
Return Value:
None.
--*/
{
KIRQL oldIrql;
if (--(DisketteExtension->ControllerData->AdapterChannelRefCount)) {
return;
}
KeRaiseIrql( DISPATCH_LEVEL, &oldIrql );
IoFreeAdapterChannel( DisketteExtension->ControllerData->AdapterObject );
KeLowerIrql( oldIrql );
}
VOID
FlAllocateIoBuffer(
IN OUT PCONTROLLER_DATA ControllerData,
IN ULONG BufferSize
)
/*++
Routine Description:
This routine allocates a PAGE_SIZE io buffer.
Arguments:
ControllerData - Supplies the controller data.
BufferSize - Supplies the number of bytes to allocate.
Return Value:
None.
--*/
{
BOOLEAN allocateContiguous;
LARGE_INTEGER maxDmaAddress;
if (ControllerData->IoBuffer) {
if (ControllerData->IoBufferSize >= BufferSize) {
return;
}
FlFreeIoBuffer(ControllerData);
}
if (BufferSize > ControllerData->NumberOfMapRegisters*PAGE_SIZE) {
allocateContiguous = TRUE;
} else {
allocateContiguous = FALSE;
}
if (allocateContiguous) {
maxDmaAddress.QuadPart = MAXIMUM_DMA_ADDRESS;
ControllerData->IoBuffer = MmAllocateContiguousMemory(BufferSize,
maxDmaAddress);
} else {
ControllerData->IoBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
BufferSize);
}
if (!ControllerData->IoBuffer) {
return;
}
ControllerData->IoBufferMdl = IoAllocateMdl(ControllerData->IoBuffer,
BufferSize, FALSE, FALSE, NULL);
if (!ControllerData->IoBufferMdl) {
if (allocateContiguous) {
MmFreeContiguousMemory(ControllerData->IoBuffer);
} else {
ExFreePool(ControllerData->IoBuffer);
}
ControllerData->IoBuffer = NULL;
return;
}
MmProbeAndLockPages(ControllerData->IoBufferMdl, KernelMode,
IoModifyAccess);
ControllerData->IoBufferSize = BufferSize;
}
VOID
FlFreeIoBuffer(
IN OUT PCONTROLLER_DATA ControllerData
)
/*++
Routine Description:
This routine free's the controller's IoBuffer.
Arguments:
ControllerData - Supplies the controller data.
Return Value:
None.
--*/
{
BOOLEAN contiguousBuffer;
if (!ControllerData->IoBuffer) {
return;
}
if (ControllerData->IoBufferSize > ControllerData->NumberOfMapRegisters*PAGE_SIZE) {
contiguousBuffer = TRUE;
} else {
contiguousBuffer = FALSE;
}
ControllerData->IoBufferSize = 0;
MmUnlockPages(ControllerData->IoBufferMdl);
IoFreeMdl(ControllerData->IoBufferMdl);
ControllerData->IoBufferMdl = NULL;
if (contiguousBuffer) {
MmFreeContiguousMemory(ControllerData->IoBuffer);
} else {
ExFreePool(ControllerData->IoBuffer);
}
ControllerData->IoBuffer = NULL;
}
VOID
FloppyThread(
PVOID Context
)
/*++
Routine Description:
This is the code executed by the system thread created when the
floppy driver initializes. This thread loops forever (or until a
flag is set telling the thread to kill itself) processing packets
put into the queue by the dispatch routines.
For each packet, this thread calls appropriate routines to process
the request, and then calls FlFinishOperation() to complete the
packet.
Arguments:
Context - a pointer to our data area for the controller being
supported (there is one thread per controller).
Return Value:
None.
--*/
{
PCONTROLLER_DATA controllerData = Context;
PIRP irp;
PIO_STACK_LOCATION irpSp;
PLIST_ENTRY request;
PDISKETTE_EXTENSION disketteExtension;
NTSTATUS ntStatus;
NTSTATUS waitStatus;
LARGE_INTEGER queueWait;
BOOLEAN interruptConnected = FALSE;
//
// Set thread priority to lowest realtime level.
//
KeSetPriorityThread(KeGetCurrentThread(), LOW_REALTIME_PRIORITY);
queueWait.QuadPart = -(3 * 1000 * 10000);
do {
//
// Wait for a request from the dispatch routines.
// KeWaitForSingleObject won't return error here - this thread
// isn't alertable and won't take APCs, and we're not passing in
// a timeout.
//
waitStatus = KeWaitForSingleObject(
(PVOID) &controllerData->RequestSemaphore,
UserRequest,
UserMode,
FALSE,
&queueWait );
if (waitStatus == STATUS_TIMEOUT) {
ExAcquireFastMutex(&controllerData->ThreadReferenceMutex);
if (controllerData->ThreadReferenceCount == 0) {
controllerData->ThreadReferenceCount = -1;
controllerData->AllowInterruptProcessing = FALSE;
FlTurnOffMotor(controllerData);
if (interruptConnected) {
IoDisconnectInterrupt(controllerData->InterruptObject);
}
ExAcquireFastMutex(PagingMutex);
if (--PagingReferenceCount == 0) {
MmPageEntireDriver(DriverEntry);
}
ExReleaseFastMutex(PagingMutex);
ExReleaseFastMutex(&controllerData->ThreadReferenceMutex);
PsTerminateSystemThread( STATUS_SUCCESS );
}
ExReleaseFastMutex(&controllerData->ThreadReferenceMutex);
continue;
}
while (request = ExInterlockedRemoveHeadList(
&controllerData->ListEntry,
&controllerData->ListSpinLock)) {
ExAcquireFastMutex(&controllerData->ThreadReferenceMutex);
ASSERT(controllerData->ThreadReferenceCount > 0);
(controllerData->ThreadReferenceCount)--;
ExReleaseFastMutex(&controllerData->ThreadReferenceMutex);
controllerData->HardwareFailed = FALSE;
irp = CONTAINING_RECORD( request, IRP, Tail.Overlay.ListEntry );
irpSp = IoGetCurrentIrpStackLocation( irp );
if (!interruptConnected) {
ntStatus = IoConnectInterrupt(&controllerData->InterruptObject,
FloppyInterruptService,
controllerData,
NULL,
controllerData->ControllerVector,
controllerData->ControllerIrql,
controllerData->ControllerIrql,
controllerData->InterruptMode,
controllerData->SharableVector,
controllerData->ProcessorMask,
controllerData->SaveFloatState);
if (!NT_SUCCESS(ntStatus)) {
irp->IoStatus.Status = ntStatus;
irp->IoStatus.Information = 0;
IoCompleteRequest(irp, IO_NO_INCREMENT);
continue;
}
interruptConnected = TRUE;
}
FloppyDump(
FLOPIRPPATH,
("Floppy: Starting up IRP: %x for extension %x\n",
irp,irpSp->Parameters.Read.Key)
);
switch ( irpSp->MajorFunction ) {
case IRP_MJ_READ:
case IRP_MJ_WRITE: {
//
// Get the diskette extension from where it was hidden
// in the IRP.
//
disketteExtension = (PDISKETTE_EXTENSION)
irpSp->Parameters.Read.Key;
//
// Until the file system clears the DO_VERIFY_VOLUME
// flag, we should return all requests with error.
//
if (( disketteExtension->DeviceObject->Flags &
DO_VERIFY_VOLUME ) &&
!(irpSp->Flags & SL_OVERRIDE_VERIFY_VOLUME))
{
FloppyDump(
FLOPINFO,
("Floppy: clearing queue; verify required\n")
);
//
// The disk changed, and we set this bit. Fail
// all current IRPs for this device; when all are
// returned, the file system will clear
// DO_VERIFY_VOLUME.
//
ntStatus = STATUS_VERIFY_REQUIRED;
} else {
//
// Allocate an adapter channel for the I/O.
//
FloppyDump(
FLOPIRPPATH,
("Floppy: About to allocate adapter channel %x\n",
controllerData->AdapterObject)
);
FlAllocateAdapterChannel(disketteExtension);
FloppyDump(
FLOPIRPPATH,
("Floppy: Allocated adapter channel %x\n",
controllerData->AdapterObject)
);
ntStatus = FlReadWrite( disketteExtension, irp, FALSE );
//
// Free the adapter channel that we just used.
//
FlFreeAdapterChannel(disketteExtension);
}
break;
}
case IRP_MJ_DEVICE_CONTROL: {
disketteExtension = (PDISKETTE_EXTENSION)
irpSp->Parameters.DeviceIoControl.Type3InputBuffer;
//
// Until the file system clears the DO_VERIFY_VOLUME
// flag, we should return all requests with error.
//
if (( disketteExtension->DeviceObject->Flags &
DO_VERIFY_VOLUME ) &&
!(irpSp->Flags & SL_OVERRIDE_VERIFY_VOLUME))
{
FloppyDump(
FLOPINFO,
("Floppy: clearing queue; verify required\n")
);
//
// The disk changed, and we set this bit. Fail
// all current IRPs; when all are returned, the
// file system will clear DO_VERIFY_VOLUME.
//
ntStatus = STATUS_VERIFY_REQUIRED;
} else {
switch (
irpSp->Parameters.DeviceIoControl.IoControlCode ) {
case IOCTL_DISK_CHECK_VERIFY: {
//
// Just start the drive; it will
// automatically check whether or not the
// disk has been changed.
//
FloppyDump(
FLOPSHOW,
("Floppy: IOCTL_DISK_CHECK_VERIFY called\n")
);
ntStatus = FlStartDrive(
disketteExtension,
irp,
FALSE,
FALSE,
FALSE);
break;
}
case IOCTL_DISK_IS_WRITABLE: {
//
// Start the drive with the WriteOperation
// flag set to TRUE.
//
FloppyDump(
FLOPSHOW,
("Floppy: IOCTL_DISK_IS_WRITABLE called\n")
);
if (disketteExtension->IsReadOnly) {
ntStatus = STATUS_INVALID_PARAMETER;
} else {
ntStatus = FlStartDrive(
disketteExtension,
irp,
TRUE,
FALSE,
TRUE);
}
break;
}
case IOCTL_DISK_GET_DRIVE_GEOMETRY: {
FloppyDump(
FLOPSHOW,
("Floppy: IOCTL_DISK_GET_DRIVE_GEOMETRY\n")
);
//
// If there's enough room to write the
// data, start the drive to make sure we
// know what type of media is in the drive.
//
if ( irpSp->Parameters.DeviceIoControl.
OutputBufferLength <
sizeof( DISK_GEOMETRY ) ) {
ntStatus = STATUS_INVALID_PARAMETER;
} else {
ntStatus = FlStartDrive(
disketteExtension,
irp,
FALSE,
TRUE,
(BOOLEAN)!!(irpSp->Flags &
SL_OVERRIDE_VERIFY_VOLUME));
}
//
// If the media wasn't formatted, FlStartDrive
// returned STATUS_UNRECOGNIZED_MEDIA.
//
if ( NT_SUCCESS( ntStatus ) ||
( ntStatus == STATUS_UNRECOGNIZED_MEDIA ) ) {
PDISK_GEOMETRY outputBuffer =
(PDISK_GEOMETRY)
irp->AssociatedIrp.SystemBuffer;
// Always return the media type, even if
// it's unknown.
//
ntStatus = STATUS_SUCCESS;
outputBuffer->MediaType =
disketteExtension->MediaType;
//
// The rest of the fields only have meaning
// if the media type is known.
//
if ( disketteExtension->MediaType ==
Unknown ) {
FloppyDump(
FLOPSHOW,
("Floppy: geometry unknown\n")
);
//
// Just zero out everything. The
// caller shouldn't look at it.
//
outputBuffer->Cylinders.LowPart = 0;
outputBuffer->Cylinders.HighPart = 0;
outputBuffer->TracksPerCylinder = 0;
outputBuffer->SectorsPerTrack = 0;
outputBuffer->BytesPerSector = 0;
} else {
//
// Return the geometry of the current
// media.
//
FloppyDump(
FLOPSHOW,
("Floppy: geomentry is known\n")
);
outputBuffer->Cylinders.LowPart =
disketteExtension->DriveMediaConstants.MaximumTrack + 1;
outputBuffer->Cylinders.HighPart = 0;
outputBuffer->TracksPerCylinder =
disketteExtension->DriveMediaConstants.NumberOfHeads;
outputBuffer->SectorsPerTrack =
disketteExtension->DriveMediaConstants.SectorsPerTrack;
outputBuffer->BytesPerSector =
disketteExtension->DriveMediaConstants.BytesPerSector;
}
FloppyDump(
FLOPSHOW,
("Floppy: Geometry\n"
"------- Cylinders low: 0x%x\n"
"------- Cylinders high: 0x%x\n"
"------- Track/Cyl: 0x%x\n"
"------- Sectors/Track: 0x%x\n"
"------- Bytes/Sector: 0x%x\n"
"------- Media Type: %d\n",
outputBuffer->Cylinders.LowPart,
outputBuffer->Cylinders.HighPart,
outputBuffer->TracksPerCylinder,
outputBuffer->SectorsPerTrack,
outputBuffer->BytesPerSector,
outputBuffer->MediaType)
);
}
irp->IoStatus.Information =
sizeof( DISK_GEOMETRY );
break;
}
case IOCTL_DISK_FORMAT_TRACKS_EX:
case IOCTL_DISK_FORMAT_TRACKS: {
FloppyDump(
FLOPSHOW,
("Floppy: IOCTL_DISK_FORMAT_TRACKS\n")
);
//
// Start the drive, and make sure it's not
// write protected.
//
ntStatus = FlStartDrive(
disketteExtension,
irp,
TRUE,
FALSE,
FALSE );
//
// Note that FlStartDrive could have returned
// STATUS_UNRECOGNIZED_MEDIA if the drive
// wasn't formatted.
//
if ( NT_SUCCESS( ntStatus ) ||
( ntStatus == STATUS_UNRECOGNIZED_MEDIA ) ) {
//
// Allocate an adapter channel to do
// the format.
//
FlAllocateAdapterChannel(disketteExtension);
//
// We need a single page to do FORMATs.
// If we already allocated a buffer,
// we'll use that. If not, let's
// allocate a single page. Note that
// we'd have to do this anyway if there's
// not enough map registers.
//
FlAllocateIoBuffer(controllerData, PAGE_SIZE);
if (controllerData->IoBuffer) {
ntStatus = FlFormat(disketteExtension,
irp);
} else {
ntStatus = STATUS_INSUFFICIENT_RESOURCES;
}
//
// Free the adapter channel.
//
FlFreeAdapterChannel(disketteExtension);
}
break;
} //end of case format
#if defined(DBCS) && defined(_MIPS_)
case IOCTL_DISK_READ:
case IOCTL_DISK_WRITE: {
FloppyDump(
FLOPSHOW,
("Floppy: IOCTL_DISK_READ WRITE\n")
);
//
// Start the drive, and make sure it's not
// write protected.
//
ntStatus = FlStartDrive(
disketteExtension,
irp,
TRUE,
FALSE,
FALSE );
//
// Allocate an adapter channel to do
// the format.
//
FlAllocateAdapterChannel(disketteExtension);
ntStatus = FlReadWrite_PTOS(
disketteExtension,
irp );
//
// Free the adapter channel.
//
FlFreeAdapterChannel(disketteExtension);
break;
} //end of case read/write
case IOCTL_DISK_SENSE_DEVICE: {
controllerData->FifoBuffer[0] = disketteExtension->DeviceUnit;
ntStatus = FlSendByte( COMMND_SENSE_DRIVE, controllerData );
if ( NT_SUCCESS( ntStatus ) ) {
ntStatus = FlSendByte(
controllerData->FifoBuffer[0],
controllerData );
if ( NT_SUCCESS( ntStatus ) ) {
ntStatus = FlGetByte(
&controllerData->FifoBuffer[0],
controllerData );
Result_Status3_PTOS[0].ST3_PTOS = controllerData->FifoBuffer[0]; //PTOS
}
}
if ( NT_SUCCESS( ntStatus ) ) {
PSENSE_DEVISE_STATUS_PTOS outputBuffer
=(PSENSE_DEVISE_STATUS_PTOS)irp->AssociatedIrp.SystemBuffer;
((PSENSE_DEVISE_STATUS_PTOS)outputBuffer)->ST3_PTOS
=Result_Status3_PTOS[0].ST3_PTOS;
irp->IoStatus.Information = sizeof( SENSE_DEVISE_STATUS_PTOS );
}
break;
} //end of case sense device
#endif // DBCS && _MIPS_
} //end of switch controlcode
}
break;
} //end of case IOCTL
default: {
FloppyDump(
FLOPDBGP,
("Floppy: bad majorfunction %x\n",irpSp->MajorFunction)
);
ntStatus = STATUS_NOT_IMPLEMENTED;
}
} //end of switch on majorfunction
if (ntStatus == STATUS_DEVICE_BUSY) {
// If the status is DEVICE_BUSY then this indicates that the
// qic117 has control of the controller. Therefore complete
// all remaining requests with STATUS_DEVICE_BUSY.
for (;;) {
controllerData->HardwareFailed = FALSE;
irp->IoStatus.Status = STATUS_DEVICE_BUSY;
IoCompleteRequest(irp, IO_DISK_INCREMENT);
request = ExInterlockedRemoveHeadList(
&controllerData->ListEntry,
&controllerData->ListSpinLock );
if (!request) {
break;
}
ExAcquireFastMutex(&controllerData->ThreadReferenceMutex);
ASSERT(controllerData->ThreadReferenceCount > 0);
(controllerData->ThreadReferenceCount)--;
ExReleaseFastMutex(&controllerData->ThreadReferenceMutex);
irp = CONTAINING_RECORD(request, IRP, Tail.Overlay.ListEntry);
}
} else {
//
// All operations leave a final status in ntStatus. Copy it
// to the IRP, and then complete the operation.
//
irp->IoStatus.Status = ntStatus;
FlFinishOperation( irp, disketteExtension );
}
} // while there's packets to process
} while ( TRUE );
}
IO_ALLOCATION_ACTION
FloppyAllocateAdapterChannel(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID MapRegisterBase,
IN PVOID Context
)
/*++
Routine Description:
This DPC is called whenever the floppy thread is trying to allocate
the adapter channel (like before doing a read or write). It saves
the MapRegisterBase in the controller data area, and sets the
AllocateAdapterChannelEvent to awaken the thread.
Arguments:
DeviceObject - unused.
Irp - unused.
MapRegisterBase - the base of the map registers that can be used
for this transfer.
Context - a pointer to our controller data area.
Return Value:
Returns Allocation Action 'KeepObject' which means that the adapter
object will be held for now (to be released explicitly later).
--*/
{
PCONTROLLER_DATA controllerData = Context;
UNREFERENCED_PARAMETER( DeviceObject );
UNREFERENCED_PARAMETER( Irp );
controllerData->MapRegisterBase = MapRegisterBase;
KeSetEvent(
&controllerData->AllocateAdapterChannelEvent,
0L,
FALSE );
return KeepObject;
}
VOID
FlConsolidateMediaTypeWithBootSector(
IN OUT PDISKETTE_EXTENSION DisketteExtension,
IN PBOOT_SECTOR_INFO BootSector
)
/*++
Routine Description:
This routine adjusts the DisketteExtension data according
to the BPB values if this is appropriate.
Arguments:
DisketteExtension - Supplies the diskette extension.
BootSector - Supplies the boot sector information.
Return Value:
None.
--*/
{
USHORT bpbNumberOfSectors, bpbNumberOfHeads;
USHORT bpbSectorsPerTrack, bpbBytesPerSector;
USHORT bpbMediaByte, bpbMaximumTrack;
MEDIA_TYPE bpbMediaType;
ULONG i, n;
PDRIVE_MEDIA_CONSTANTS readidDriveMediaConstants;
BOOLEAN changeToBpbMedia;
FloppyDump(
FLOPSHOW,
("Floppy: First sector read: media descriptor is: 0x%x\n",
BootSector->MediaByte[0])
);
if (BootSector->JumpByte[0] != 0xeb &&
BootSector->JumpByte[0] != 0xe9) {
// This is not a formatted floppy so ignore the BPB.
return;
}
bpbNumberOfSectors = BootSector->NumberOfSectors[1]*0x100 +
BootSector->NumberOfSectors[0];
bpbNumberOfHeads = BootSector->NumberOfHeads[1]*0x100 +
BootSector->NumberOfHeads[0];
bpbSectorsPerTrack = BootSector->SectorsPerTrack[1]*0x100 +
BootSector->SectorsPerTrack[0];
bpbBytesPerSector = BootSector->BytesPerSector[1]*0x100 +
BootSector->BytesPerSector[0];
bpbMediaByte = BootSector->MediaByte[0];
if (!bpbNumberOfHeads || !bpbSectorsPerTrack) {
// Invalid BPB, avoid dividing by zero.
return;
}
bpbMaximumTrack = bpbNumberOfSectors/bpbNumberOfHeads/bpbSectorsPerTrack - 1;
// First figure out if this BPB specifies a known media type
// independantly of the current drive type.
bpbMediaType = Unknown;
for (i = 0; i < NUMBER_OF_DRIVE_MEDIA_COMBINATIONS; i++) {
if (bpbBytesPerSector == DriveMediaConstants[i].BytesPerSector &&
bpbSectorsPerTrack == DriveMediaConstants[i].SectorsPerTrack &&
bpbMaximumTrack == DriveMediaConstants[i].MaximumTrack &&
bpbNumberOfHeads == DriveMediaConstants[i].NumberOfHeads &&
bpbMediaByte == DriveMediaConstants[i].MediaByte) {
bpbMediaType = DriveMediaConstants[i].MediaType;
break;
}
}
FloppyDump(
FLOPSHOW,
("FLOPPY: After switch media type is: %x\n",bpbMediaType)
);
FloppyDump(
FLOPINFO,
("FloppyBpb: Media type ")
);
if (bpbMediaType == DisketteExtension->MediaType) {
// No conflict between BPB and readId result.
changeToBpbMedia = FALSE;
FloppyDump(
FLOPINFO,
("is same\n")
);
} else {
// There is a conflict between the BPB and the readId
// media type. If the new parameters are acceptable
// then go with them.
readidDriveMediaConstants = &(DisketteExtension->DriveMediaConstants);
if (bpbBytesPerSector == readidDriveMediaConstants->BytesPerSector &&
bpbSectorsPerTrack < 0x100 &&
bpbMaximumTrack == readidDriveMediaConstants->MaximumTrack &&
bpbNumberOfHeads <= readidDriveMediaConstants->NumberOfHeads) {
changeToBpbMedia = TRUE;
} else {
changeToBpbMedia = FALSE;
}
FloppyDump(
FLOPINFO,
("%s", changeToBpbMedia ? "will change to Bpb\n" : "will not change\n")
);
// If we didn't derive a new media type from the BPB then
// just use the one from readId. Also override any
// skew compensation since we don't really know anything
// about this new media type.
if (bpbMediaType == Unknown) {
bpbMediaType = readidDriveMediaConstants->MediaType;
DisketteExtension->DriveMediaConstants.SkewDelta = 0;
}
}
if (changeToBpbMedia) {
// Change the DriveMediaType only if this new media type
// falls in line with what is supported by the drive.
i = DriveMediaLimits[DisketteExtension->DriveType].LowestDriveMediaType;
n = DriveMediaLimits[DisketteExtension->DriveType].HighestDriveMediaType;
for (; i <= n; i++) {
if (bpbMediaType == DriveMediaConstants[i].MediaType) {
DisketteExtension->DriveMediaType = i;
break;
}
}
DisketteExtension->MediaType = bpbMediaType;
DisketteExtension->ByteCapacity = bpbNumberOfSectors*bpbBytesPerSector;
DisketteExtension->DriveMediaConstants.SectorsPerTrack = (UCHAR) bpbSectorsPerTrack;
DisketteExtension->DriveMediaConstants.NumberOfHeads = (UCHAR) bpbNumberOfHeads;
// If the MSDMF3. signature is there then make this floppy
// read-only.
if (RtlCompareMemory(BootSector->OemData, "MSDMF3.", 7) == 7) {
DisketteExtension->IsReadOnly = TRUE;
}
}
}
VOID
FlCheckBootSector(
IN OUT PDISKETTE_EXTENSION DisketteExtension
)
/*++
Routine Description:
This routine reads the boot sector and then figures
out whether or not the boot sector contains new geometry
information.
Arguments:
DisketteExtension - Supplies the diskette extension.
Return Value:
None.
--*/
{
#define BOOT_SECTOR_SIZE 512
PBOOT_SECTOR_INFO bootSector;
LARGE_INTEGER offset;
PIRP irp;
NTSTATUS status;
// Set up the IRP to read the boot sector.
bootSector = ExAllocatePool(NonPagedPoolCacheAligned, BOOT_SECTOR_SIZE);
if (!bootSector) {
return;
}
offset.LowPart = offset.HighPart = 0;
irp = IoBuildAsynchronousFsdRequest(IRP_MJ_READ,
DisketteExtension->DeviceObject,
bootSector,
BOOT_SECTOR_SIZE,
&offset,
NULL);
if (!irp) {
ExFreePool(bootSector);
return;
}
irp->CurrentLocation--;
irp->Tail.Overlay.CurrentStackLocation = IoGetNextIrpStackLocation(irp);
// Allocate an adapter channel, do read, free adapter channel.
FlAllocateAdapterChannel(DisketteExtension);
status = FlReadWrite(DisketteExtension, irp, TRUE);
FlFreeAdapterChannel(DisketteExtension);
MmUnlockPages(irp->MdlAddress);
IoFreeMdl(irp->MdlAddress);
IoFreeIrp(irp);
ExFreePool(bootSector);
}
NTSTATUS
FlReadWriteTrack(
IN OUT PDISKETTE_EXTENSION DisketteExtension,
IN OUT PMDL IoMdl,
IN OUT PVOID IoBuffer,
IN BOOLEAN WriteOperation,
IN UCHAR Cylinder,
IN UCHAR Head,
IN UCHAR Sector,
IN UCHAR NumberOfSectors,
IN BOOLEAN NeedSeek
)
/*++
Routine Description:
This routine reads a portion of a track. It transfers the to or from the
device from or to the given IoBuffer and IoMdl.
Arguments:
DisketteExtension - Supplies the diskette extension.
IoMdl - Supplies the Mdl for transfering from/to the device.
IoBuffer - Supplies the buffer to transfer from/to the device.
WriteOperation - Supplies whether or not this is a write operation.
Cylinder - Supplies the cylinder number for this track.
Head - Supplies the head number for this track.
Sector - Supplies the starting sector of the transfer.
NumberOfSectors - Supplies the number of sectors to transfer.
NeedSeek - Supplies whether or not we need to do a seek.
Return Value:
An NTSTATUS code.
--*/
{
PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
ULONG byteToSectorShift;
PCONTROLLER_DATA controllerData;
ULONG transferBytes;
LARGE_INTEGER headSettleTime;
NTSTATUS status;
ULONG seekRetry, ioRetry;
BOOLEAN recalibrateDrive = FALSE;
UCHAR i;
FloppyDump(
FLOPSHOW,
("\nFlReadWriteTrack:%sseek for %s at chs %d/%d/%d for %d sectors\n",
NeedSeek ? " need " : " ",
WriteOperation ? "write" : "read",
Cylinder,
Head,
Sector,
NumberOfSectors)
);
driveMediaConstants = &DisketteExtension->DriveMediaConstants;
byteToSectorShift = SECTORLENGTHCODE_TO_BYTESHIFT +
driveMediaConstants->SectorLengthCode;
controllerData = DisketteExtension->ControllerData;
transferBytes = ((ULONG) NumberOfSectors)<<byteToSectorShift;
headSettleTime.LowPart = -(10*1000*driveMediaConstants->HeadSettleTime);
headSettleTime.HighPart = -1;
for (seekRetry = 0, ioRetry = 0; seekRetry < 3; seekRetry++) {
if (recalibrateDrive) {
// Something failed, so recalibrate the drive.
FloppyDump(
FLOPINFO,
("FlReadWriteTrack: performing recalibrate\n")
);
FlRecalibrateDrive(DisketteExtension);
}
// Do a seek if we have to.
if (recalibrateDrive ||
(NeedSeek &&
(!controllerData->ControllerConfigurable ||
driveMediaConstants->CylinderShift != 0))) {
controllerData->FifoBuffer[0] = (Head<<2) |
DisketteExtension->DeviceUnit;
controllerData->FifoBuffer[1] = Cylinder<<
driveMediaConstants->CylinderShift;
status = FlIssueCommand(COMMND_SEEK, DisketteExtension);
if (NT_SUCCESS(status)) {
// Check the completion state of the controller.
if (!(controllerData->FifoBuffer[0]&STREG0_SEEK_COMPLETE) ||
controllerData->FifoBuffer[1] !=
Cylinder<<driveMediaConstants->CylinderShift) {
controllerData->HardwareFailed = TRUE;
status = STATUS_FLOPPY_BAD_REGISTERS;
}
if (NT_SUCCESS(status)) {
// Delay after doing seek.
KeDelayExecutionThread(KernelMode, FALSE, &headSettleTime);
// SEEKs should always be followed by a READID.
controllerData->FifoBuffer[0] = (Head<<2) |
DisketteExtension->DeviceUnit;
status = FlIssueCommand(COMMND_READ_ID + COMMND_MFM,
DisketteExtension);
if (NT_SUCCESS(status)) {
if (controllerData->FifoBuffer[0] !=
((Head<<2) | DisketteExtension->DeviceUnit) ||
controllerData->FifoBuffer[1] != 0 ||
controllerData->FifoBuffer[2] != 0 ||
controllerData->FifoBuffer[3] != Cylinder) {
controllerData->HardwareFailed = TRUE;
status = FlInterpretError(
controllerData->FifoBuffer[1],
controllerData->FifoBuffer[2]);
}
} else {
FloppyDump(
FLOPINFO,
("FlReadWriteTrack: Read ID failed %x\n", status)
);
}
}
} else {
FloppyDump(
FLOPINFO,
("FlReadWriteTrack: SEEK failed %x\n", status)
);
}
} else {
status = STATUS_SUCCESS;
}
if (!NT_SUCCESS(status)) {
// The seek failed so try again.
FloppyDump(
FLOPINFO,
("FlReadWriteTrack: setup failure %x - recalibrating\n", status)
);
recalibrateDrive = TRUE;
continue;
}
for (;; ioRetry++) {
// We've done the seek or the seek will be implied.
// Do the read. Map the transfer through the DMA.
KeFlushIoBuffers(IoMdl, !WriteOperation, TRUE);
//
// We can ignore the logical address returned by
// IoMapTransfer, since we're not using busmaster
// stuff.
//
IoMapTransfer(controllerData->AdapterObject,
IoMdl, controllerData->MapRegisterBase,
IoBuffer, &transferBytes, WriteOperation);
//
// Issue the READ or WRITE command
//
controllerData->FifoBuffer[0] = (Head<<2) |
DisketteExtension->DeviceUnit;
controllerData->FifoBuffer[1] = Cylinder;
controllerData->FifoBuffer[2] = Head;
controllerData->FifoBuffer[3] = Sector + 1;
controllerData->FifoBuffer[4] =
driveMediaConstants->SectorLengthCode;
controllerData->FifoBuffer[5] = Sector + NumberOfSectors;
controllerData->FifoBuffer[6] =
driveMediaConstants->ReadWriteGapLength;
controllerData->FifoBuffer[7] = driveMediaConstants->DataLength;
if (WriteOperation) {
status = FlIssueCommand(COMMND_WRITE_DATA + COMMND_MFM,
DisketteExtension);
} else {
status = FlIssueCommand(COMMND_READ_DATA + COMMND_MFM,
DisketteExtension);
}
//
// Flush the DMA adapter buffers.
//
IoFlushAdapterBuffers(controllerData->AdapterObject,
IoMdl, controllerData->MapRegisterBase,
IoBuffer, transferBytes, WriteOperation);
if (NT_SUCCESS(status)) {
if ((controllerData->FifoBuffer[0]&STREG0_END_MASK) !=
STREG0_END_NORMAL &&
((controllerData->FifoBuffer[0]&STREG0_END_MASK) !=
STREG0_END_ERROR ||
controllerData->FifoBuffer[1] != STREG1_END_OF_DISKETTE ||
controllerData->FifoBuffer[2] != STREG2_SUCCESS)) {
controllerData->HardwareFailed = TRUE;
status = FlInterpretError(controllerData->FifoBuffer[1],
controllerData->FifoBuffer[2]);
}
} else {
FloppyDump(
FLOPINFO,
("FlReadWriteTrack: %s command failed %x\n",
WriteOperation ? "write" : "read",
status)
);
}
if (NT_SUCCESS(status)) {
break;
}
if (ioRetry >= 2) {
FloppyDump(
FLOPINFO,
("FlReadWriteTrack: too many retries - failing\n")
);
break;
}
}
if (NT_SUCCESS(status)) {
break;
}
// We failed quite a bit so make seeks mandatory.
recalibrateDrive = TRUE;
}
if (!NT_SUCCESS(status) && NumberOfSectors > 1) {
// Retry one sector at a time.
FloppyDump(
FLOPINFO,
("FlReadWriteTrack: Attempting sector at a time\n")
);
for (i = 0; i < NumberOfSectors; i++) {
status = FlReadWriteTrack(DisketteExtension, IoMdl,
((PCHAR) IoBuffer) +
(((ULONG) i)<<byteToSectorShift),
WriteOperation, Cylinder, Head,
(UCHAR) (Sector + i), 1, FALSE);
if (!NT_SUCCESS(status)) {
FloppyDump(
FLOPINFO,
("FlReadWriteTrack: failed sector %d status %x\n",
i,
status)
);
break;
}
}
}
return status;
}
NTSTATUS
FlReadWrite(
IN OUT PDISKETTE_EXTENSION DisketteExtension,
IN OUT PIRP Irp,
IN BOOLEAN DriveStarted
)
/*++
Routine Description:
This routine is called by the floppy thread to read/write data
to/from the diskette. It breaks the request into pieces called
"transfers" (their size depends on the buffer size, where the end of
the track is, etc) and retries each transfer until it succeeds or
the retry count is exceeded.
Arguments:
DisketteExtension - a pointer to our data area for the drive to be
accessed.
Irp - a pointer to the IO Request Packet.
DriveStarted - indicated whether or not the drive has been started.
Return Value:
STATUS_SUCCESS if the packet was successfully read or written; the
appropriate error is propogated otherwise.
--*/
{
PIO_STACK_LOCATION irpSp;
PCONTROLLER_DATA controllerData;
BOOLEAN writeOperation;
NTSTATUS status;
PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
ULONG byteToSectorShift;
ULONG currentSector, firstSector, lastSector;
ULONG trackSize;
UCHAR sectorsPerTrack, numberOfHeads;
UCHAR currentHead, currentCylinder, trackSector;
PCHAR userBuffer;
UCHAR skew, skewDelta;
UCHAR numTransferSectors;
PMDL mdl;
PCHAR ioBuffer;
irpSp = IoGetCurrentIrpStackLocation(Irp);
controllerData = DisketteExtension->ControllerData;
FloppyDump(
FLOPSHOW,
("FlReadWrite: for %s at offset %x size %x ",
irpSp->MajorFunction == IRP_MJ_WRITE ? "write" : "read",
irpSp->Parameters.Read.ByteOffset.LowPart,
irpSp->Parameters.Read.Length)
);
// Check for valid operation on this device.
if (irpSp->MajorFunction == IRP_MJ_WRITE) {
if (DisketteExtension->IsReadOnly) {
FloppyDump(
FLOPSHOW,
("is read-only\n")
);
return STATUS_INVALID_PARAMETER;
}
writeOperation = TRUE;
} else {
writeOperation = FALSE;
}
FloppyDump(
FLOPSHOW,
("\n")
);
// Start up the drive.
if (DriveStarted) {
status = STATUS_SUCCESS;
} else {
status = FlStartDrive(DisketteExtension, Irp, writeOperation, TRUE,
(BOOLEAN)!!(irpSp->Flags&SL_OVERRIDE_VERIFY_VOLUME));
}
if (!NT_SUCCESS(status)) {
FloppyDump(
FLOPSHOW,
("FlReadWrite: error on start %x\n", status)
);
return status;
}
if (DisketteExtension->MediaType == Unknown) {
FloppyDump(
FLOPSHOW,
("not recognized\n")
);
return STATUS_UNRECOGNIZED_MEDIA;
}
// The drive has started up with a recognized media.
// Gather some relavant parameters.
driveMediaConstants = &DisketteExtension->DriveMediaConstants;
byteToSectorShift = SECTORLENGTHCODE_TO_BYTESHIFT +
driveMediaConstants->SectorLengthCode;
firstSector = irpSp->Parameters.Read.ByteOffset.LowPart>>
byteToSectorShift;
lastSector = firstSector + (irpSp->Parameters.Read.Length>>
byteToSectorShift);
sectorsPerTrack = driveMediaConstants->SectorsPerTrack;
numberOfHeads = driveMediaConstants->NumberOfHeads;
userBuffer = MmGetSystemAddressForMdl(Irp->MdlAddress);
trackSize = ((ULONG) sectorsPerTrack)<<byteToSectorShift;
skew = 0;
skewDelta = driveMediaConstants->SkewDelta;
for (currentSector = firstSector;
currentSector < lastSector;
currentSector += numTransferSectors) {
// Compute cylinder, head and sector from absolute sector.
currentCylinder = (UCHAR) (currentSector/sectorsPerTrack/numberOfHeads);
trackSector = (UCHAR) (currentSector%sectorsPerTrack);
currentHead = (UCHAR) (currentSector/sectorsPerTrack%numberOfHeads);
numTransferSectors = sectorsPerTrack - trackSector;
if (lastSector - currentSector < numTransferSectors) {
numTransferSectors = (UCHAR) (lastSector - currentSector);
}
//
// If we're using a temporary IO buffer because of
// insufficient registers in the DMA and we're
// doing a write then copy the write buffer to
// the contiguous buffer.
//
if (trackSize > controllerData->NumberOfMapRegisters*PAGE_SIZE) {
FlAllocateIoBuffer(controllerData, trackSize);
if (!controllerData->IoBuffer) {
FloppyDump(
FLOPSHOW,
("FlReadWrite: no resources\n")
);
return STATUS_INSUFFICIENT_RESOURCES;
}
mdl = controllerData->IoBufferMdl;
ioBuffer = controllerData->IoBuffer;
if (writeOperation) {
RtlMoveMemory(ioBuffer,
userBuffer + ((currentSector - firstSector)<<
byteToSectorShift),
((ULONG) numTransferSectors)<<byteToSectorShift);
}
} else {
mdl = Irp->MdlAddress;
ioBuffer = (PCHAR) MmGetMdlVirtualAddress(Irp->MdlAddress) +
((currentSector - firstSector)<<byteToSectorShift);
}
//
// Transfer the track.
// Do what we can to avoid missing revs.
//
// Alter the skew to be in the range of what
// we're transfering.
if (skew >= numTransferSectors + trackSector) {
skew = 0;
}
if (skew < trackSector) {
skew = trackSector;
}
// Go from skew to the end of the irp.
status = FlReadWriteTrack(
DisketteExtension, mdl,
ioBuffer + (((ULONG) skew - trackSector)<<byteToSectorShift),
writeOperation, currentCylinder, currentHead, skew,
(UCHAR) (numTransferSectors + trackSector - skew), TRUE);
// Go from start of irp to skew.
if (NT_SUCCESS(status) && skew > trackSector) {
status = FlReadWriteTrack(
DisketteExtension, mdl, ioBuffer, writeOperation,
currentCylinder, currentHead, trackSector,
(UCHAR) (skew - trackSector), FALSE);
} else {
skew = (numTransferSectors + trackSector)%sectorsPerTrack;
}
if (!NT_SUCCESS(status)) {
break;
}
//
// If we used the temporary IO buffer to do the
// read then copy the contents back to the IRPs buffer.
//
if (!writeOperation &&
trackSize > controllerData->NumberOfMapRegisters*PAGE_SIZE) {
RtlMoveMemory(userBuffer + ((currentSector - firstSector)<<
byteToSectorShift),
ioBuffer, ((ULONG) numTransferSectors)<<byteToSectorShift);
KeFlushIoBuffers(Irp->MdlAddress, TRUE, FALSE);
}
//
// Increment the skew. Do this even if just switching sides
// for National Super I/O chips.
//
skew = (skew + skewDelta)%sectorsPerTrack;
}
Irp->IoStatus.Information = (currentSector - firstSector)<<byteToSectorShift;
// If the read was successful then consolidate the
// boot sector with the determined density.
if (NT_SUCCESS(status) && firstSector == 0) {
FlConsolidateMediaTypeWithBootSector(DisketteExtension,
(PBOOT_SECTOR_INFO) userBuffer);
}
FloppyDump(
FLOPSHOW,
("FlReadWrite: completed status %x information %d\n", status, Irp->IoStatus.Information)
);
return status;
}
NTSTATUS
FlFormat(
IN PDISKETTE_EXTENSION DisketteExtension,
IN PIRP Irp
)
/*++
Routine Description:
This routine is called by the floppy thread to format some tracks on
the diskette. This won't take TOO long because the FORMAT utility
is written to only format a few tracks at a time so that it can keep
a display of what percentage of the disk has been formatted.
Arguments:
DisketteExtension - pointer to our data area for the diskette to be
formatted.
Irp - pointer to the IO Request Packet.
Return Value:
STATUS_SUCCESS if the tracks were formatted; appropriate error
propogated otherwise.
--*/
{
LARGE_INTEGER headSettleTime;
PCONTROLLER_DATA controllerData;
PIO_STACK_LOCATION irpSp;
PBAD_TRACK_NUMBER badTrackBuffer;
PFORMAT_PARAMETERS formatParameters;
PFORMAT_EX_PARAMETERS formatExParameters;
PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
NTSTATUS ntStatus;
ULONG badTrackBufferLength;
DRIVE_MEDIA_TYPE driveMediaType;
UCHAR driveStatus;
UCHAR numberOfBadTracks = 0;
UCHAR currentTrack;
UCHAR endTrack;
UCHAR whichSector;
UCHAR retryCount;
BOOLEAN bufferOverflow = FALSE;
FloppyDump(
FLOPSHOW,
("Floppy: FlFormat...\n")
);
controllerData = DisketteExtension->ControllerData;
irpSp = IoGetCurrentIrpStackLocation( Irp );
formatParameters = (PFORMAT_PARAMETERS) Irp->AssociatedIrp.SystemBuffer;
if (irpSp->Parameters.DeviceIoControl.IoControlCode ==
IOCTL_DISK_FORMAT_TRACKS_EX) {
formatExParameters =
(PFORMAT_EX_PARAMETERS) Irp->AssociatedIrp.SystemBuffer;
} else {
formatExParameters = NULL;
}
FloppyDump(
FLOPFORMAT,
("Floppy: Format Params - MediaType: %d\n"
"------ Start Cyl: %x\n"
"------ End Cyl: %x\n"
"------ Start Hd: %d\n"
"------ End Hd: %d\n",
formatParameters->MediaType,
formatParameters->StartCylinderNumber,
formatParameters->EndCylinderNumber,
formatParameters->StartHeadNumber,
formatParameters->EndHeadNumber)
);
badTrackBufferLength =
irpSp->Parameters.DeviceIoControl.OutputBufferLength;
//
// Figure out which entry in the DriveMediaConstants table to use.
// We know we'll find one, or FlCheckFormatParameters() would have
// rejected the request.
//
driveMediaType =
DriveMediaLimits[DisketteExtension->DriveType].HighestDriveMediaType;
while ( ( DriveMediaConstants[driveMediaType].MediaType !=
formatParameters->MediaType ) &&
( driveMediaType > DriveMediaLimits[DisketteExtension->DriveType].
LowestDriveMediaType ) ) {
driveMediaType--;
}
driveMediaConstants = &DriveMediaConstants[driveMediaType];
//
// Set some values in the diskette extension to indicate what we
// know about the media type.
//
DisketteExtension->MediaType = formatParameters->MediaType;
DisketteExtension->DriveMediaType = driveMediaType;
DisketteExtension->DriveMediaConstants = DriveMediaConstants[driveMediaType];
if (formatExParameters) {
DisketteExtension->DriveMediaConstants.SectorsPerTrack =
(UCHAR) formatExParameters->SectorsPerTrack;
DisketteExtension->DriveMediaConstants.FormatGapLength =
(UCHAR) formatExParameters->FormatGapLength;
}
driveMediaConstants = &(DisketteExtension->DriveMediaConstants);
DisketteExtension->BytesPerSector = driveMediaConstants->BytesPerSector;
DisketteExtension->ByteCapacity =
( driveMediaConstants->BytesPerSector ) *
driveMediaConstants->SectorsPerTrack *
( 1 + driveMediaConstants->MaximumTrack ) *
driveMediaConstants->NumberOfHeads;
currentTrack = (UCHAR)( ( formatParameters->StartCylinderNumber *
driveMediaConstants->NumberOfHeads ) +
formatParameters->StartHeadNumber );
endTrack = (UCHAR)( ( formatParameters->EndCylinderNumber *
driveMediaConstants->NumberOfHeads ) +
formatParameters->EndHeadNumber );
FloppyDump(
FLOPFORMAT,
("Floppy: Format - Starting/ending tracks: %x/%x\n",
currentTrack,
endTrack)
);
//
// Set the data rate (which depends on the drive/media
// type).
//
if ( controllerData->LastDriveMediaType != driveMediaType ) {
ntStatus = FlDatarateSpecifyConfigure( DisketteExtension );
if ( !NT_SUCCESS( ntStatus ) ) {
return ntStatus;
}
}
//
// Since we're doing a format, make this drive writable.
//
DisketteExtension->IsReadOnly = FALSE;
//
// Format each track.
//
do {
//
// Seek to proper cylinder
//
controllerData->FifoBuffer[0] = DisketteExtension->DeviceUnit;
controllerData->FifoBuffer[1] = (UCHAR)( ( currentTrack /
driveMediaConstants->NumberOfHeads ) <<
driveMediaConstants->CylinderShift );
FloppyDump(
FLOPFORMAT,
("Floppy: Format seek to cylinder: %x\n",
controllerData->FifoBuffer[1])
);
ntStatus = FlIssueCommand( COMMND_SEEK, DisketteExtension );
if ( NT_SUCCESS( ntStatus ) ) {
if ( ( controllerData->FifoBuffer[0] & STREG0_SEEK_COMPLETE ) &&
( controllerData->FifoBuffer[1] == (UCHAR)( ( currentTrack /
driveMediaConstants->NumberOfHeads ) <<
driveMediaConstants->CylinderShift ) ) ) {
//
// Must delay HeadSettleTime milliseconds before
// doing anything after a SEEK.
//
headSettleTime.LowPart = - ( 10 * 1000 *
driveMediaConstants->HeadSettleTime );
headSettleTime.HighPart = -1;
KeDelayExecutionThread(
KernelMode,
FALSE,
&headSettleTime );
//
// Read ID. Note that we don't bother checking the return
// registers, because if this media wasn't formatted we'd
// get an error.
//
controllerData->FifoBuffer[0] = DisketteExtension->DeviceUnit;
ntStatus = FlIssueCommand(
COMMND_READ_ID + COMMND_MFM,
DisketteExtension );
} else {
FloppyDump(
FLOPWARN,
("Floppy: format's seek returned bad registers\n"
"------ Statusreg0 = %x\n"
"------ Statusreg1 = %x\n",
controllerData->FifoBuffer[0],
controllerData->FifoBuffer[1])
);
controllerData->HardwareFailed = TRUE;
ntStatus = STATUS_FLOPPY_BAD_REGISTERS;
}
}
if ( !NT_SUCCESS( ntStatus ) ) {
FloppyDump(
FLOPWARN,
("Floppy: format's seek/readid returned %x\n", ntStatus)
);
return ntStatus;
}
//
// Fill the buffer with the format of this track.
//
for (whichSector = 0;
whichSector < driveMediaConstants->SectorsPerTrack;
whichSector++) {
controllerData->IoBuffer[whichSector*4] =
currentTrack/driveMediaConstants->NumberOfHeads;
controllerData->IoBuffer[whichSector*4 + 1] =
currentTrack%driveMediaConstants->NumberOfHeads;
if (formatExParameters) {
controllerData->IoBuffer[whichSector*4 + 2] =
(UCHAR) formatExParameters->SectorNumber[whichSector];
} else {
controllerData->IoBuffer[whichSector*4 + 2] = whichSector + 1;
}
controllerData->IoBuffer[whichSector*4 + 3] =
driveMediaConstants->SectorLengthCode;
FloppyDump(
FLOPFORMAT,
("Floppy - Format table entry %x - %x/%x/%x/%x\n",
whichSector,
controllerData->IoBuffer[whichSector*4],
controllerData->IoBuffer[whichSector*4 + 1],
controllerData->IoBuffer[whichSector*4 + 2],
controllerData->IoBuffer[whichSector*4 + 3])
);
}
//
// Retry until success or too many retries.
//
retryCount = 0;
do {
ULONG length;
length = driveMediaConstants->BytesPerSector;
//
// Map the transfer from the buffer to the disk.
//
KeFlushIoBuffers( controllerData->IoBufferMdl, FALSE, TRUE );
IoMapTransfer(
controllerData->AdapterObject,
controllerData->IoBufferMdl,
controllerData->MapRegisterBase,
controllerData->IoBuffer,
&length,
TRUE );
//
// Issue command to format track
//
controllerData->FifoBuffer[0] = (UCHAR)
( ( ( currentTrack % driveMediaConstants->NumberOfHeads ) << 2 )
| DisketteExtension->DeviceUnit );
controllerData->FifoBuffer[1] =
driveMediaConstants->SectorLengthCode;
controllerData->FifoBuffer[2] =
driveMediaConstants->SectorsPerTrack;
controllerData->FifoBuffer[3] =
driveMediaConstants->FormatGapLength;
controllerData->FifoBuffer[4] =
driveMediaConstants->FormatFillCharacter;
FloppyDump(
FLOPFORMAT,
("Floppy: format command parameters\n"
"------ Head/Unit: %x\n"
"------ Bytes/Sector: %x\n"
"------ Sectors/Cylinder: %x\n"
"------ Gap 3: %x\n"
"------ Filler Byte: %x\n",
controllerData->FifoBuffer[0],
controllerData->FifoBuffer[1],
controllerData->FifoBuffer[2],
controllerData->FifoBuffer[3],
controllerData->FifoBuffer[4])
);
ntStatus = FlIssueCommand(
COMMND_FORMAT_TRACK + COMMND_MFM,
DisketteExtension );
IoFlushAdapterBuffers(
controllerData->AdapterObject,
controllerData->IoBufferMdl,
controllerData->MapRegisterBase,
controllerData->IoBuffer,
length,
TRUE );
if ( !NT_SUCCESS( ntStatus ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: format returned %x\n", ntStatus)
);
}
if ( NT_SUCCESS( ntStatus ) ) {
//
// Check the return bytes from the controller.
//
if ( ( controllerData->FifoBuffer[0] &
( STREG0_DRIVE_FAULT |
STREG0_END_INVALID_COMMAND ) )
|| ( controllerData->FifoBuffer[1] &
STREG1_DATA_OVERRUN ) ||
( controllerData->FifoBuffer[2] != 0 ) ) {
FloppyDump(
FLOPWARN,
("Floppy: format had bad registers\n"
"------ Streg0 = %x\n"
"------ Streg1 = %x\n"
"------ Streg2 = %x\n",
controllerData->FifoBuffer[0],
controllerData->FifoBuffer[1],
controllerData->FifoBuffer[2])
);
controllerData->HardwareFailed = TRUE;
ntStatus = FlInterpretError(
controllerData->FifoBuffer[1],
controllerData->FifoBuffer[2] );
}
}
} while ( ( !NT_SUCCESS( ntStatus ) ) &&
( retryCount++ < RECALIBRATE_RETRY_COUNT ) );
if ( !NT_SUCCESS( ntStatus ) ) {
driveStatus = READ_CONTROLLER(
&controllerData->ControllerAddress->DRDC.DiskChange );
if ( (DisketteExtension->DriveType != DRIVE_TYPE_0360) &&
FlDisketteRemoved(controllerData, driveStatus, FALSE) ) {
//
// The user apparently popped the floppy. Return error
// rather than logging bad track.
//
return ntStatus;
}
//
// Log the bad track.
//
FloppyDump(
FLOPDBGP,
("Floppy: track %x is bad\n", currentTrack)
);
if ( badTrackBufferLength >= (ULONG)
( ( numberOfBadTracks + 1 ) * sizeof( BAD_TRACK_NUMBER ) ) ) {
badTrackBuffer = (PBAD_TRACK_NUMBER)
Irp->AssociatedIrp.SystemBuffer;
badTrackBuffer[numberOfBadTracks] = ( BAD_TRACK_NUMBER )
currentTrack;
} else {
bufferOverflow = TRUE;
}
numberOfBadTracks++;
}
currentTrack++;
} while ( currentTrack <= endTrack );
if ( ( NT_SUCCESS( ntStatus ) ) && ( bufferOverflow ) ) {
ntStatus = STATUS_BUFFER_OVERFLOW;
}
return ntStatus;
}
BOOLEAN
FlCheckFormatParameters(
IN PDISKETTE_EXTENSION DisketteExtension,
IN PFORMAT_PARAMETERS FormatParameters
)
/*++
Routine Description:
This routine checks the supplied format parameters to make sure that
they'll work on the drive to be formatted.
Arguments:
DisketteExtension - a pointer to our data area for the diskette to
be formatted.
FormatParameters - a pointer to the caller's parameters for the FORMAT.
Return Value:
TRUE if parameters are OK.
FALSE if the parameters are bad.
--*/
{
PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
DRIVE_MEDIA_TYPE driveMediaType;
//
// Figure out which entry in the DriveMediaConstants table to use.
//
driveMediaType =
DriveMediaLimits[DisketteExtension->DriveType].HighestDriveMediaType;
while ( ( DriveMediaConstants[driveMediaType].MediaType !=
FormatParameters->MediaType ) &&
( driveMediaType > DriveMediaLimits[DisketteExtension->DriveType].
LowestDriveMediaType ) ) {
driveMediaType--;
}
if ( DriveMediaConstants[driveMediaType].MediaType !=
FormatParameters->MediaType ) {
return FALSE;
} else {
driveMediaConstants = &DriveMediaConstants[driveMediaType];
if ( ( FormatParameters->StartHeadNumber >
(ULONG)( driveMediaConstants->NumberOfHeads - 1 ) ) ||
( FormatParameters->EndHeadNumber >
(ULONG)( driveMediaConstants->NumberOfHeads - 1 ) ) ||
( FormatParameters->StartCylinderNumber >
driveMediaConstants->MaximumTrack ) ||
( FormatParameters->EndCylinderNumber >
driveMediaConstants->MaximumTrack ) ||
( FormatParameters->EndCylinderNumber <
FormatParameters->StartCylinderNumber ) ) {
return FALSE;
} else {
return TRUE;
}
}
}
PCONTROLLER
FlGetControllerBase(
IN INTERFACE_TYPE BusType,
IN ULONG BusNumber,
PHYSICAL_ADDRESS IoAddress,
ULONG NumberOfBytes,
BOOLEAN InIoSpace,
PBOOLEAN MappedAddress
)
/*++
Routine Description:
This routine maps an IO address to system address space.
Arguments:
BusType - what type of bus - eisa, mca, isa
IoBusNumber - which IO bus (for machines with multiple buses).
IoAddress - base device address to be mapped.
NumberOfBytes - number of bytes for which address is valid.
InIoSpace - indicates an IO address.
MappedAddress - indicates whether the address was mapped.
This only has meaning if the address returned
is non-null.
Return Value:
Mapped address
--*/
{
PHYSICAL_ADDRESS cardAddress;
ULONG addressSpace = InIoSpace;
PCONTROLLER Address;
if (!HalTranslateBusAddress(
BusType,
BusNumber,
IoAddress,
&addressSpace,
&cardAddress
)) {
return NULL;
}
//
// Map the device base address into the virtual address space
// if the address is in memory space.
//
if (!addressSpace) {
Address = MmMapIoSpace(
cardAddress,
NumberOfBytes,
FALSE
);
*MappedAddress = !!Address;
} else {
Address = (PCONTROLLER)cardAddress.LowPart;
*MappedAddress = FALSE;
}
return Address;
}
VOID
FlLogErrorDpc(
IN PKDPC Dpc,
IN PVOID DeferredContext,
IN PVOID SystemContext1,
IN PVOID SystemContext2
)
/*++
Routine Description:
This routine is merely used to log an error that we had to reset the device.
Arguments:
Dpc - The dpc object.
DeferredContext - A pointer to the controller data.
SystemContext1 - Unused.
SystemContext2 - Unused.
Return Value:
Mapped address
--*/
{
PIO_ERROR_LOG_PACKET errorLogEntry;
PCONTROLLER_DATA controllerData = DeferredContext;
errorLogEntry = IoAllocateErrorLogEntry(
controllerData->DriverObject,
(UCHAR)(sizeof(IO_ERROR_LOG_PACKET))
);
if ( errorLogEntry != NULL) {
errorLogEntry->ErrorCode = IO_ERR_RESET;
errorLogEntry->SequenceNumber = 0;
errorLogEntry->MajorFunctionCode = 0;
errorLogEntry->RetryCount = 0;
errorLogEntry->UniqueErrorValue = 0;
errorLogEntry->FinalStatus = STATUS_SUCCESS;
errorLogEntry->DumpDataSize = 0;
IoWriteErrorLogEntry(errorLogEntry);
}
}
#if defined(DBCS) && defined(_MIPS_)
NTSTATUS
FlOutputCommandFor3Mode(
IN UCHAR Command,
IN OUT PDISKETTE_EXTENSION DisketteExtension
)
/*++
Routine Description:
This routine is merely used to log an error that we had to reset the device.
Arguments:
Command - a byte specifying the command to be sent to the controller.
DisketteExtension - a pointer to our data area for the drive being
accessed (any drive if a controller command is being given).
Return Value:
STATUS_SUCCESS if the command was sent and bytes received properly;
appropriate error propogated otherwise.
--*/
{
KIRQL oldIrql;
PCONTROLLER_DATA controllerData;
UCHAR configurationRegister5;
UCHAR needDrive1600kbMode;
NTSTATUS ntStatus;
UCHAR save_FifoBuffer[10];
ULONG i;
ntStatus = STATUS_SUCCESS;
if (DisketteExtension->Drive3Mode == DRIVE_2MODE) {
return ntStatus;
}
if (((Command & ~(COMMND_MFM)) != COMMND_READ_ID) &&
((Command & ~(COMMND_MFM)) != COMMND_READ_DATA) &&
((Command & ~(COMMND_MFM)) != COMMND_WRITE_DATA) &&
((Command & ~(COMMND_MFM)) != COMMND_READ_DELETED_DATA) &&
((Command & ~(COMMND_MFM)) != COMMND_SEEK) &&
((Command & ~(COMMND_MFM)) != COMMND_RECALIBRATE) &&
((Command & ~(COMMND_MFM)) != COMMND_WRITE_DELETED_DATA)) {
return ntStatus;
}
controllerData = DisketteExtension->ControllerData;
if ((DisketteExtension->DriveMediaType == Drive144Media120) ||
(DisketteExtension->DriveMediaType == Drive144Media123) ||
((DisketteExtension->DriveMediaConstants).SectorsPerTrack == 0x1b) ||
((DisketteExtension->DriveMediaConstants).SectorsPerTrack == 0x1a)) {
needDrive1600kbMode = TRUE;
} else {
needDrive1600kbMode = FALSE;
}
KeAcquireSpinLock( &controllerData->TimerSpinLock, &oldIrql );
WRITE_CONTROLLER(
&controllerData->ControllerAddress->StatusA,
CONFIG5_ENTER_MODE);
WRITE_CONTROLLER(
&controllerData->ControllerAddress->StatusA,
CONFIG5_ENTER_MODE);
KeReleaseSpinLock( &controllerData->TimerSpinLock, oldIrql );
WRITE_CONTROLLER(
&controllerData->ControllerAddress->StatusA,
CONFIG5_SELECT_CR5);
configurationRegister5 = READ_CONTROLLER(
&controllerData->ControllerAddress->StatusB);
if (((configurationRegister5 & CONFIG5_1600KB_MODE_MASK) ==
CONFIG5_1600KB_MODE) && (needDrive1600kbMode == FALSE)) {
//
// the CR5 is set the 1.6MB mode, but the required access mode
// is the 2.0MB mode. So the CR5 is changed into 2.0MB mode.
//
WRITE_CONTROLLER(
&controllerData->ControllerAddress->StatusB,
(configurationRegister5 & ~(CONFIG5_1600KB_MODE)));
} else if (((configurationRegister5 & CONFIG5_1600KB_MODE_MASK) !=
CONFIG5_1600KB_MODE) && (needDrive1600kbMode == TRUE)) {
//
// the CR5 is set the 2.0MB mode, but the required access mode
// is the 1.6MB mode. So the CR5 is changed into 1.6MB mode.
//
WRITE_CONTROLLER(
&controllerData->ControllerAddress->StatusB,
(configurationRegister5 | CONFIG5_1600KB_MODE));
}
WRITE_CONTROLLER(
&controllerData->ControllerAddress->StatusA,
CONFIG5_EXIT_MODE);
if (((configurationRegister5 & CONFIG5_1600KB_MODE_MASK) !=
CONFIG5_1600KB_MODE) && (needDrive1600kbMode == TRUE) &&
(((DisketteExtension->DriveMediaConstants).SectorsPerTrack == 0x1b) ||
((DisketteExtension->DriveMediaConstants).SectorsPerTrack == 0x1a))) {
//
// If the controller has a CONFIGURE command, use it to enable implied
// seeks. If it doesn't, we'll find out here the first time through.
//
for ( i = 0; i < 10; i++ ) {
save_FifoBuffer[i] = controllerData->FifoBuffer[i];
}
if ( controllerData->ControllerConfigurable ) {
controllerData->FifoBuffer[0] = 0;
controllerData->FifoBuffer[1] = COMMND_CONFIGURE_FIFO_THRESHOLD +
COMMND_CONFIGURE_DISABLE_POLLING;
if (!DisketteExtension->DriveMediaConstants.CylinderShift) {
controllerData->FifoBuffer[1] += COMMND_CONFIGURE_IMPLIED_SEEKS;
}
controllerData->FifoBuffer[2] = 0;
ntStatus = FlIssueCommand( COMMND_CONFIGURE, DisketteExtension );
if ( ntStatus == STATUS_DEVICE_NOT_READY ) {
//
// Note the CONFIGURE command doesn't exist. Set status to
// success, so we can issue the SPECIFY command below.
//
FloppyDump(
FLOPINFO,
("Floppy: Ignore above error - no CONFIGURE command\n")
);
controllerData->ControllerConfigurable = FALSE;
ntStatus = STATUS_SUCCESS;
}
}
//
// Issue SPECIFY command to program the head load and unload
// rates, the drive step rate, and the DMA data transfer mode.
//
if ( NT_SUCCESS( ntStatus ) ) {
controllerData->FifoBuffer[0] =
DisketteExtension->DriveMediaConstants.StepRateHeadUnloadTime;
controllerData->FifoBuffer[1] =
DisketteExtension->DriveMediaConstants.HeadLoadTime;
ntStatus = FlIssueCommand( COMMND_SPECIFY, DisketteExtension );
if ( NT_SUCCESS( ntStatus ) ) {
//
// Program the data rate
//
WRITE_CONTROLLER(
&controllerData->ControllerAddress->DRDC.DataRate,
DisketteExtension->DriveMediaConstants.DataTransferRate );
}
}
for ( i = 0; i < 10; i++ ) {
controllerData->FifoBuffer[i] = save_FifoBuffer[i];
}
}
return ntStatus;
}
NTSTATUS
FlReadWrite_PTOS(
IN PDISKETTE_EXTENSION DisketteExtension,
IN PIRP Irp
)
/*++
Routine Description:
This routine is called by the floppy thread to read write one tracks on
the diskette.
Arguments:
DisketteExtension - a pointer to our data area for the diskette to be
read write.
Irp - a pointer to the IO Request Packet.
Return Value:
STATUS_SUCCESS
--*/
{
LARGE_INTEGER headSettleTime;
PIO_STACK_LOCATION irpSp;
PCONTROLLER_DATA controllerData;
PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
PUCHAR userBuffer;
NTSTATUS ntStatus;
NTSTATUS ntStatus2;
ULONG startingSectorOfTransfer;
ULONG totalBytesOfTransfer;
ULONG bytesTransferredSoFar = 0;
ULONG numberOfPagesInTransfer;
UCHAR transferCylinder;
UCHAR transferSector;
UCHAR transferHead;
UCHAR byteToSectorShift;
UCHAR retryCount;
UCHAR secondaryRetryCount;
UCHAR mediaDescriptor;
DRIVE_MEDIA_TYPE driveMediaType;
MEDIA_TYPE mediaType;
BOOLEAN writeOperation;
BOOLEAN fatalError;
BOOLEAN needToUseBuffer;
BOOLEAN fifoDisabled = FALSE;
PDISK_READ_WRITE_PARAMETER_PTOS readwriteParameters;
UCHAR command;
FloppyDump(
FLOPSHOW,
("Floppy: FlReadWrite_PTOS...3\n")
);
controllerData = DisketteExtension->ControllerData;
readwriteParameters = (PDISK_READ_WRITE_PARAMETER_PTOS) Irp->AssociatedIrp.SystemBuffer;
irpSp = IoGetCurrentIrpStackLocation( Irp );
switch( irpSp->Parameters.DeviceIoControl.IoControlCode ) {
case IOCTL_DISK_READ: {
writeOperation = FALSE;
if (readwriteParameters->Read_Write_Mode_PTOS == 0) {
FloppyDump(
FLOPSHOW,
("Floppy: IOCTL_ReadData...\n")
);
command = COMMND_READ_DATA;
} else {
FloppyDump(
FLOPSHOW,
("Floppy: IOCTL_ReadDeletedData...\n")
);
command = COMMND_READ_DELETED_DATA;
}
break;
}
case IOCTL_DISK_WRITE: {
writeOperation = TRUE;
if (readwriteParameters->Read_Write_Mode_PTOS == 0) {
FloppyDump(
FLOPSHOW,
("Floppy: IOCTL_WriteData...\n")
);
command = COMMND_WRITE_DATA;
} else {
FloppyDump(
FLOPSHOW,
("Floppy: IOCTL_WriteDeletedData...\n")
);
command = COMMND_WRITE_DELETED_DATA;
}
break;
}
}
FloppyDump(
FLOPSHOW,
("Floppy: IOCTL Read Write - Mode : %d\n"
"------ Start Cyl: %x\n"
"------ End Cyl: %x\n"
"------ Start Hd: %d\n"
"------ End Hd: %d\n",
readwriteParameters->Read_Write_Mode_PTOS,
readwriteParameters->CylinderNumber_PTOS,
readwriteParameters->HeadNumber_PTOS,
readwriteParameters->StartSectorNumber_PTOS,
readwriteParameters->NumberOfSectors_PTOS)
);
if ((readwriteParameters->CylinderNumber_PTOS ==0) &&
(readwriteParameters->HeadNumber_PTOS ==0)) {
driveMediaConstants =
&DriveMediaConstantsPTOS[4];
} else {
driveMediaConstants =
&DriveMediaConstantsPTOS[3];
}
//
// For 3mode floppy disk drive
//
DisketteExtension->DriveMediaConstants = *driveMediaConstants;
//
// Initialize variables to be used in the loop that transfers
// portions of the request.
//
byteToSectorShift = (UCHAR)( SECTORLENGTHCODE_TO_BYTESHIFT +
driveMediaConstants->SectorLengthCode );
fatalError = FALSE;
userBuffer = (PUCHAR) MmGetSystemAddressForMdl( Irp->MdlAddress );
//
// Determine the initial sector to be read from the diskette.
//
transferCylinder = (UCHAR)readwriteParameters->CylinderNumber_PTOS;
transferSector = (UCHAR)readwriteParameters->StartSectorNumber_PTOS;
transferHead = (UCHAR)readwriteParameters->HeadNumber_PTOS;
totalBytesOfTransfer = (readwriteParameters->NumberOfSectors_PTOS << byteToSectorShift);
FloppyDump(
FLOPSTATUS,
("Floppy: SectorsPerTrack = %x\n"
"------ NumberOfHeads = %x\n"
"------ transferCylinder = %x\n"
"------ transferSector = %x\n"
"------ transferHead = %x\n",
driveMediaConstants->SectorsPerTrack,
driveMediaConstants->NumberOfHeads,
transferCylinder,
transferSector,
transferHead)
);
//
// Make sure the transfer doesn't go past the end of the track
//
needToUseBuffer = TRUE;
FloppyDump(
FLOPSHOW,
("Floppy: TransferLength = %lx\n", totalBytesOfTransfer)
);
//
// If this is a write and we have to use the contiguous buffer
// (because we don't have enough map registers) then copy the
// data from the user's buffer to the contiguous buffer.
//
#if 0
if ( ( needToUseBuffer ) &&
( writeOperation ) ) {
FloppyDump(
FLOPSHOW,
("Floppy: Writing from address %lx\n",
userBuffer + bytesTransferredSoFar)
);
RtlMoveMemory(
controllerData->IoBuffer,
(PVOID)( userBuffer + bytesTransferredSoFar ),
totalBytesOfTransfer );
}
#else
#endif
retryCount = 0;
secondaryRetryCount = 0;
//
// Try this transfer until it succeeds or is failed.
//
do {
//
// If the controller doesn't do an implicit seek, then do an
// explicit one.
//
// Also do an explicit seek if this drive isn't set up to
// seek properly on this media, as noted by CylinderShift.
// (This happens for 360kb diskettes in 1.2Mb drives).
//
controllerData->FifoBuffer[0] = DisketteExtension->DeviceUnit;
ntStatus = FlSendByte( COMMND_SENSE_DRIVE, controllerData );
if ( NT_SUCCESS( ntStatus ) ) {
ntStatus = FlSendByte(
controllerData->FifoBuffer[0],
controllerData );
if ( NT_SUCCESS( ntStatus ) ) {
ntStatus = FlGetByte(
&controllerData->FifoBuffer[0],
controllerData );
Result_Status3_PTOS[0].ST3_PTOS = controllerData->FifoBuffer[0];
}
}
if ( ( !controllerData->ControllerConfigurable ) ||
( driveMediaConstants->CylinderShift != 0 ) ) {
controllerData->FifoBuffer[0] = (UCHAR)
( ( transferHead << 2 ) | DisketteExtension->DeviceUnit );
controllerData->FifoBuffer[1] = (UCHAR)( transferCylinder <<
driveMediaConstants->CylinderShift );
FloppyDump(
FLOPSHOW,
("Floppy: Issuing SEEK to %x\n",
controllerData->FifoBuffer[1])
);
#ifdef KEEP_COUNTERS
FloppyUsedSeek++;
#endif
ntStatus = FlIssueCommand( COMMND_SEEK, DisketteExtension );
if ( !NT_SUCCESS( ntStatus ) ) {
FloppyDump(
FLOPWARN,
("Floppy: SEEK returned %x\n", ntStatus)
);
}
if ( NT_SUCCESS( ntStatus ) ) {
FloppyDump(
FLOPSHOW,
("Floppy: SEEK says we got to cylinder %x\n",
controllerData->FifoBuffer[1])
);
if ( controllerData->FifoBuffer[1] != (UCHAR)
( transferCylinder <<
driveMediaConstants->CylinderShift ) ) {
FloppyDump(
FLOPWARN,
("Floppy: Seek returned bad registers\n")
);
controllerData->HardwareFailed = TRUE;
ntStatus = STATUS_FLOPPY_BAD_REGISTERS;
} else {
//
// Must delay HeadSettleTime milliseconds before
// doing anything after a SEEK.
//
headSettleTime.LowPart = - ( 10 * 1000 *
driveMediaConstants->HeadSettleTime );
headSettleTime.HighPart = -1;
KeDelayExecutionThread(
KernelMode,
FALSE,
&headSettleTime );
//
// SEEKs should always be followed by a READID.
//
controllerData->FifoBuffer[0] = (UCHAR)
( ( transferHead << 2 ) |
DisketteExtension->DeviceUnit );
}
}
} else {
#ifdef KEEP_COUNTERS
FloppyNoSeek++;
#endif
}
//
// Start the operation on the DMA and floppy hardware.
//
if ( NT_SUCCESS( ntStatus ) ) {
//
// Map the transfer through the DMA hardware. How we do
// it depends on whether we're using the user's buffer
// or our own contiguous buffer.
//
#if 0
KeFlushIoBuffers(
controllerData->IoBufferMdl,
!writeOperation,
TRUE );
//
// We can ignore the logical address returned by
// IoMapTransfer, since we're not using busmaster
// stuff.
//
IoMapTransfer(
controllerData->AdapterObject,
controllerData->IoBufferMdl,
controllerData->MapRegisterBase,
controllerData->IoBuffer,
&totalBytesOfTransfer,
(BOOLEAN)writeOperation);
#else
KeFlushIoBuffers( Irp->MdlAddress, !writeOperation, TRUE );
IoMapTransfer(
controllerData->AdapterObject,
Irp->MdlAddress,
controllerData->MapRegisterBase,
(PVOID)( (ULONG) MmGetMdlVirtualAddress(Irp->MdlAddress)
+ bytesTransferredSoFar ),
&totalBytesOfTransfer,
(BOOLEAN)writeOperation);
#endif
if ( controllerData->ControllerConfigurable &&
(command != COMMND_WRITE_DELETED_DATA)) {
//
// We enable the FIFO threshold brfore issuing
// the WRITE DELETE DATA command.
//
controllerData->FifoBuffer[0] = 0;
controllerData->FifoBuffer[1] =
COMMND_CONFIGURE_IMPLIED_SEEKS +
COMMND_CONFIGURE_FIFO_THRESHOLD +
COMMND_CONFIGURE_DISABLE_POLLING;
controllerData->FifoBuffer[0] = 0;
ntStatus2 = FlIssueCommand( COMMND_CONFIGURE, DisketteExtension );
}
//
// Issue the READ or WRITE command
//
controllerData->FifoBuffer[0] = (UCHAR)
( ( transferHead << 2 ) | DisketteExtension->DeviceUnit );
controllerData->FifoBuffer[1] = transferCylinder;
controllerData->FifoBuffer[2] = transferHead;
controllerData->FifoBuffer[3] = transferSector;
controllerData->FifoBuffer[4] =
driveMediaConstants->SectorLengthCode;
controllerData->FifoBuffer[5] = (UCHAR)( (transferSector - 1) +
( totalBytesOfTransfer >> byteToSectorShift ) );
controllerData->FifoBuffer[6] =
driveMediaConstants->ReadWriteGapLength;
controllerData->FifoBuffer[7] = driveMediaConstants->DataLength;
FloppyDump(
FLOPSHOW,
("Floppy: R/W params:\n"
"------ head+unit = %x\n"
"------ cylinder = %x\n"
"------ head = %x\n"
"------ sector = %x\n"
"------ seclen code = %x\n"
"------ numsecs = %x\n"
"------ rw gap len = %x\n"
"------ datalen = %x\n",
controllerData->FifoBuffer[0],
controllerData->FifoBuffer[1],
controllerData->FifoBuffer[2],
controllerData->FifoBuffer[3],
controllerData->FifoBuffer[4],
controllerData->FifoBuffer[5],
controllerData->FifoBuffer[6],
controllerData->FifoBuffer[7])
);
if ( !writeOperation ) {
if (driveMediaConstants->SectorsPerTrack!=26){
/** 1s only FM mode **/
ntStatus = FlIssueCommand(
command + COMMND_MFM,
DisketteExtension );
} else {
ntStatus = FlIssueCommand(
command,
DisketteExtension );
}
FloppyDump(
FLOPDBGP,
("Floppy: READ DATA! : \n"
"------ userBuffer is : %lx\n",
userBuffer));
} else {
if (driveMediaConstants->SectorsPerTrack!=26){
/** 1s only FM mode **/
ntStatus = FlIssueCommand(
command + COMMND_MFM,
DisketteExtension );
} else {
ntStatus = FlIssueCommand(
command ,
DisketteExtension );
}
FloppyDump(
FLOPDBGP,
("Floppy: WRITE DATA! : \n"
"------ userBuffer is : %lx\n",
userBuffer));
}
if ( !NT_SUCCESS( ntStatus ) ) {
FloppyDump(
FLOPWARN,
("Floppy: read/write returned %x\n", ntStatus)
);
}
}
Result_Status_PTOS[0].ST0_PTOS
= controllerData->FifoBuffer[0];
Result_Status_PTOS[0].ST1_PTOS
= controllerData->FifoBuffer[1];
Result_Status_PTOS[0].ST2_PTOS
= controllerData->FifoBuffer[2];
Result_Status_PTOS[0].C_PTOS
= controllerData->FifoBuffer[3];
Result_Status_PTOS[0].H_PTOS
= controllerData->FifoBuffer[4];
Result_Status_PTOS[0].R_PTOS
= controllerData->FifoBuffer[5];
Result_Status_PTOS[0].N_PTOS
= controllerData->FifoBuffer[6];
if ( NT_SUCCESS( ntStatus ) ) {
if ( ( ( controllerData->FifoBuffer[0] & STREG0_END_MASK ) !=
STREG0_END_NORMAL ) &&
( ( ( controllerData->FifoBuffer[0] & STREG0_END_MASK ) !=
STREG0_END_ERROR ) ||
( controllerData->FifoBuffer[1] !=
STREG1_END_OF_DISKETTE ) ||
( controllerData->FifoBuffer[2] != STREG2_SUCCESS ) ) ) {
FloppyDump(
FLOPWARN,
("Floppy: Status registers wrong after I/O\n")
);
controllerData->HardwareFailed = TRUE;
ntStatus = FlInterpretError(
controllerData->FifoBuffer[1],
controllerData->FifoBuffer[2] );
FloppyDump(
FLOPWARN,
("Floppy: Register values are\n"
"------ StatusRegister0 = %x\n"
"------ StatusRegister1 = %x\n"
"------ StatusRegister2 = %x\n"
"------ actualCylinder = %x\n"
"------ actualHead = %x\n"
"------ actualSector = %x\n"
"------ actualSectorLengthCode = %x\n",
controllerData->FifoBuffer[0],
controllerData->FifoBuffer[1],
controllerData->FifoBuffer[2],
controllerData->FifoBuffer[3],
controllerData->FifoBuffer[4],
controllerData->FifoBuffer[5],
controllerData->FifoBuffer[6])
);
}
}
if ( !NT_SUCCESS( ntStatus ) ) {
//
// Operation failed. Recalibrate drive & try again.
//
FloppyDump(
FLOPWARN,
("Floppy: operation failed. Recalibrating...\n")
);
ntStatus2 = FlRecalibrateDrive( DisketteExtension );
if ( NT_SUCCESS( ntStatus2 ) ) {
retryCount++;
} else {
//
// Ugh, we can't even recalibrate the drive. Force
// ourselves out of this nasty loop.
//
retryCount = RECALIBRATE_RETRY_COUNT;
fatalError = TRUE;
FloppyDump(
FLOPWARN,
("Floppy: Operation AND recalibrate failed\n")
);
}
}
if ( retryCount == RECALIBRATE_RETRY_COUNT ) {
//
// The retry count is exhausted. If the FIFO has
// overrun, reset the retry count and increment
// the secondary retry count - FIFO overruns mean that
// another device is hogging the DMA, so give the floppy
// another chance to make good.
//
if ( controllerData->FifoBuffer[1] & STREG1_DATA_OVERRUN ) {
if ( secondaryRetryCount < OVERRUN_RETRY_COUNT ) {
secondaryRetryCount++;
retryCount = 0;
} else {
//
// It looks like another device is STILL hogging
// the DMA. Before failing, try disabling the
// FIFO, if it exists.
//
if ( controllerData->ControllerConfigurable ) {
if ( fifoDisabled ||
(command != COMMND_WRITE_DELETED_DATA)) {
//
// We already disabled it, and still
// failed. Or The command is WRITE DELETED DATA.
// Exit with failure.
//
fatalError = TRUE;
} else {
fifoDisabled = FALSE;
ntStatus = STATUS_SUCCESS;
FloppyDump(
FLOPINFO,
("Floppy: disabling FIFO\n")
);
controllerData->FifoBuffer[0] = 0;
controllerData->FifoBuffer[1] =
COMMND_CONFIGURE_IMPLIED_SEEKS +
COMMND_CONFIGURE_DISABLE_FIFO +
COMMND_CONFIGURE_DISABLE_POLLING;
controllerData->FifoBuffer[2] = 0;
ntStatus = FlIssueCommand(
COMMND_CONFIGURE,
DisketteExtension );
if ( NT_SUCCESS( ntStatus ) ) {
fifoDisabled = TRUE;
}
}
} else {
//
// No FIFO to disable. Just exit with error.
//
fatalError = TRUE;
}
}
} else {
//
// Not an overrun error.
//
fatalError = TRUE;
}
}
//
// Flush the DMA adapter buffers.
//
#if 0
IoFlushAdapterBuffers(
controllerData->AdapterObject,
controllerData->IoBufferMdl,
controllerData->MapRegisterBase,
controllerData->IoBuffer,
totalBytesOfTransfer,
(BOOLEAN)writeOperation);
#else
IoFlushAdapterBuffers(
controllerData->AdapterObject,
Irp->MdlAddress,
controllerData->MapRegisterBase,
(PVOID)( (ULONG) MmGetMdlVirtualAddress( Irp->MdlAddress )
+ bytesTransferredSoFar ),
totalBytesOfTransfer,
(BOOLEAN)writeOperation);
#endif
} while ( ( !NT_SUCCESS( ntStatus ) ) &&
( retryCount < RECALIBRATE_RETRY_COUNT ) );
if ( NT_SUCCESS( ntStatus ) ) {
#if 0
if ( ( !writeOperation ) && ( needToUseBuffer ) ) {
//
// copy data from contiguous buffer
//
FloppyDump(
FLOPSHOW,
("Floppy: Reading to address %lx\n",
userBuffer + bytesTransferredSoFar)
);
RtlMoveMemory(
(PVOID)( userBuffer + bytesTransferredSoFar ),
controllerData->IoBuffer,
totalBytesOfTransfer );
}
#else
#endif
}
if ( fifoDisabled ) {
//
// We disabled the FIFO threshold. Restore it now.
//
controllerData->FifoBuffer[0] = 0;
controllerData->FifoBuffer[1] = COMMND_CONFIGURE_IMPLIED_SEEKS +
COMMND_CONFIGURE_FIFO_THRESHOLD + COMMND_CONFIGURE_DISABLE_POLLING;
controllerData->FifoBuffer[2] = 0;
ntStatus2 = FlIssueCommand( COMMND_CONFIGURE, DisketteExtension );
if ( !NT_SUCCESS( ntStatus2 ) ) {
FloppyDump(
FLOPDBGP,
("Floppy: restoring FIFO after r/w gave %x\n", ntStatus2)
);
}
}
//
// The bytesTransferred so far is correct even if there was an error.
//
Irp->IoStatus.Information = totalBytesOfTransfer;
FloppyDump(
FLOPIRPPATH,
("Floppy: done with read/write for irp %x extension %x\n",
Irp,DisketteExtension)
);
return ntStatus;
}
#endif // DBCS && _MIPS_
Reference in New Issue Copy Permalink