![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to floppy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / scsi / floppy|
Return to floppy.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / scsi / floppy |
1.1 root 1: /*++
2:
3: Copyright (c) 1991 Microsoft Corporation
4:
5: Module Name:
6:
7: floppy.c
8:
9: Abstract:
10:
11: This is the NEC PD756 (aka AT, aka ISA, aka ix86) and Intel 82077
12: (aka MIPS) floppy diskette driver for NT.
13:
14: Author:
15:
16: Chad Schwitters (chads) 14-Jul-1991.
17:
18: Environment:
19:
20: Kernel mode only.
21:
22: Revision History:
23:
24: 02-Aug-1991 (chads) Made driver work on MIPS as well as ix86.
25:
26: Notes:
27:
28: The NEC PD765 is the controller standard used on almost all ISA PCs
29: (Industry Standard Architecture, which use Intel x86 processors).
30: More advanced controllers like the Intel 82077 (which is used on
31: many MIPS machines) are supersets of the PD765 standard.
32:
33:
34: Overview of this driver:
35:
36: This driver must deal with floppy drives, and the media that may
37: or may not be in them. "Drive" and "controller" refer to the
38: hardware connected to the machine, and "media" or "diskette"
39: refers to the floppy that gets inserted into the drive.
40:
41: Communicating with the controller can involve a lot of delays,
42: so this driver creates a thread to talk to the controller (since
43: we can't wait in another thread's context). The initialization
44: and dispatch routines are executed in the context of the caller,
45: and the ISR and DPC routines could be anywhere, but everything
46: else is executed in the context of the thread. The dispatch
47: routines put requests into an interlocked queue and signal the
48: thread; the thread wakes up and processes the requests serially.
49:
50: A big advantage of the thread approach is that synchronization
51: problems are almost non-existent. Interrupts always come when
52: the floppy is blocked and waiting for them (well, there could be
53: a spurious interrupt, but the ISR won't do anything critical in
54: that event), so the only opening for contention is with the DPC
55: that turns off the drive motor. A spin lock is used to keep the
56: thread and the DPC from trying to access variables or registers
57: at the same time.
58:
59: Data structures include a controller extension that holds all
60: variables common to the controller, a device extension that
61: holds all variables common to the drive, and a read-only table
62: that holds parameters used for communicating with the controller
63: given a drive/media combination. The data structures will be
64: described in more detail later.
65:
66: Since this driver deals with removable media, it must do its
67: share of volume tracking. Before processing any packet, it must
68: check some flags - if the volume needs to be verified, the
69: packet must be returned with STATUS_VERIFY_REQUIRED. Then, the
70: disk's changeline must be checked. If it is set, it should be
71: reset, and the packet should be returned with
72: STATUS_VERIFY_REQUIRED. (If it can't be reset, then the packet
73: should be failed with STATUS_NO_MEDIA_IN_DEVICE).
74:
75: Before any operation, the motor timer must be cancelled, the
76: drive must be selected, its motor must be turned on and given a
77: chance to spin up, the changeline must be checked (and possibly
78: dealt with as mentioned above), write access (if requested) must
79: be checked, and the media type must be determined.
80:
81: Determining the media type is an unusual process. The drive
82: type is obtained from the configuration manager at
83: initialization time. Any time that the changeline is set (which
84: includes startup) the media type is unknown, and must be
85: determined. The DriveMediaLimits table is used to determine
86: which drive/media combinations are allowable, and the driver
87: assumes that the media with the largest capacity is in the
88: drive. It sets up the controller to read that media, and tries
89: to read an ID mark from the disk. As long as that fails, it
90: tries a lower media type. If no media type works, an error is
91: returned. If one works, it is assumed to properly indicate the
92: media in the drive, but it could be wrong because some
93: drive/media combinations use the same controller parameters. So
94: whenever we find that the first sector on the disk is being read
95: (which should be the first thing the file system does for a new
96: disk; this will work even if the media type assumption is wrong)
97: we sneak a peek at the media descriptor byte and change our
98: assumption about the media type if necessary.
99:
100: An operation passed in by the system is called a "request".
101: This driver often breaks the request into smaller pieces called
102: "transfers" because of limitations in the amount of data that
103: can be read or written at one time.
104:
105: At the end of any operation, the motor timer (MotorTimer in the
106: controller object) should be started. If the timer runs for a
107: couple of seconds without getting cancelled, it should turn the
108: motor off.
109:
110: Background on hardware operation:
111:
112: The following info was gathered from a number of technical
113: reference documents and existing device drivers. These sources
114: often did not agree; where there was a problem, I tried to
115: determine the answer by consensus or experimentation.
116:
117: At initialization, the following steps should be performed:
118:
119: reset the controller
120: wait for an interrupt
121: for each diskette
122: issue SENSE INTERRUPT STATUS command
123: optionally issue the CONFIGURE command
124: issue SPECIFY command
125: program the data rate
126:
127: The data rate, CONFIGURE and SPECIFY information should be
128: reprogrammed after every reset.
129:
130: To do a SEEK or RECALIBRATE, the motor should be turned on and
131: the command should be issued. After the interrupt comes, a
132: SENSE INTERRUPT STATUS command should be issued.
133:
134: To do a READ or WRITE, the motor should be turned on, and left
135: to spin up for at least 500ms. The recorded data rate of the
136: inserted media can then be determined by performing a READ ID at
137: each data rate until a successful status is returned. Then
138: there should be a seek, followed by at least a 15ms head
139: settling time. DMA is set up, and the command is issued. When
140: the data has been transferred, the controller will interrupt.
141:
142: If an error is encountered, two more retries should be performed
143: by reinitializing the DMA and re-issuing the command. If that
144: fails, the disk should be recalibrated and the seek repeated for
145: two more tries.
146:
147: The following registers can be used to program the floppy
148: controller. Each is discussed in detail below:
149:
150: AT JAZZ Read/ Register Name
151: Address Address Write (for this driver)
152:
153: 3f2 write DriveControl
154: 3f4 read Status
155: 3f5 both Fifo
156: 3f7 write DataRate
157: 3f7 read DiskChange
158:
159: Notes on other register usages:
160:
161: 3f0 is used by the Intel chip, but only for PS/2s.
162:
163: 3f1 is readable on Compaqs, and called "media id". The
164: Intel chip only uses 3f1 on PS/2s.
165:
166: 3f2 is readable on the Intel chip.
167:
168: 3f3 doesn't appear to be used by anybody.
169:
170: 3f4 is writable and called "data rate select" on the Intel
171: chip.
172:
173: 3f6 is used for fixed disk operations.
174:
175: 3f7 does not seem to be mentioned by one [old] reference,
176: but all the others do - and it seems to be essential, so I'm
177: going to use it.
178:
179: DriveControl (aka "digital output", aka "floppy operations"):
180:
181: bits 0-1: drive select (values 10 and 11 not always used)
182: bit 2: 0 = reset controller, 1 = enable controller
183: bit 3: 0 = interrupts and DMA disabled, 1 = enabled
184: bit 4: 0 = drive 1 motor off, 1 = on
185: bit 5: 0 = drive 2 motor off, 1 = on
186: bit 6: 0 = drive 3 motor off, 1 = on (not always used)
187: bit 7: 0 = drive 4 motor off, 1 = on (not always used)
188:
189: Note that a drive cannot be selected unless its motor is on
190: (setting the bits at the same time is acceptable).
191:
192: Status:
193:
194: bit 0: drive 0 busy (seeking or recalibrating)
195: bit 1: drive 1 busy
196: bit 2: drive 2 busy (not always used)
197: bit 3: drive 3 busy (not always used)
198: bit 4: controller busy (from command byte until result phase)
199: bit 5: DMA is not being used
200: bit 6: 0 = data from processor to controller, 1 = reverse
201: bit 7: 1 = data ready to be transferred
202:
203: Note that command bytes can't be written to the DATA
204: register unless bit 7 is 1 and bit 6 is 0. Similarly,
205: result bytes can't be read from the DATA register unless bit
206: 7 is 1 and bit 6 is 1. The delay for this to become true
207: could be 175us on the Intel chip; older chips may take
208: longer.
209:
210: Fifo (aka "data"):
211:
212: All commands are written here one byte at a time, and all
213: results are similarly read from here. Commands and results
214: are discussed below.
215:
216: Some controllers have a buffer and programmable threshold,
217: which allows the data to be sent in chunks rather than one
218: byte at a time. This reduces the chance of an overrun.
219:
220: After some commands, the values of status registers (and
221: other things) are returned through the Fifo register.
222: Here's the layout of the status registers:
223:
224: Status Register 0:
225:
226: bits 0-1: drive number
227: bit 2: head
228: bit 3: set if drive is not ready
229: bit 4: set if drive faults, or recalibrate didn't find
230: track 0
231: bit 5: set when seek is completed
232: bits 6-7: 00 = normal termination
233: 01 = abnormal termination, error
234: 10 = invalid command
235: 11 = abnormal termination, drive became not ready
236:
237: Status Register 1:
238:
239: bit 0: set if the ID address mark wasn't found
240: bit 1: set if write-protection detected during a write
241: bit 2: set if sector not found
242: bit 3: always 0
243: bit 4: set for data overrun
244: bit 5: set if CRC error detected in ID or data
245: bit 6: always 0
246: bit 7: set on attempt to access a sector beyond the end of a
247: cylinder
248:
249: Status Register 2:
250:
251: bit 0: set if data address or deleted data mark not found
252: bit 1: set if bad cylinder found
253: bit 2: set if SCAN fails to find sector meeting condition
254: bit 3: set if SCAN command meets "equal" condition
255: bit 4: set if wrong cylinder found
256: bit 5: set if CRC error detected in data
257: bit 6: set if deleted address data mark encountered during
258: READ or SCAN
259: bit 7: always 0
260:
261: Status Register 3:
262:
263: bits 0-1: drive number
264: bit 2: head
265: bit 3: set if drive is two-sided
266: bit 4: set if drive is on track 0
267: bit 5: set if the drive is ready
268: bit 6: set if the drive is write-protected
269: bit 7: set if the drive has faulted
270:
271: DataRate (aka "configuration control"):
272:
273: bits 0-1: 00 = 500 kb/s, 01 = 300, 10 = 250, 11 = 1 Mb/s for
274: 3.5" and 125 kb/s for 5.25"
275: bits 2-7: reserved, 0
276:
277: DiskChange (aka "digital input", aka "diskette status"):
278:
279: bits 0-6: reserved (often used for fixed disks)
280: bit 7: 1 = previous diskette has been removed
281:
282: Common Commands:
283:
284: Each command and its parameters are given to the controller
285: through the Data register. The controller then executes the
286: command. When finished, the results can be read from the
287: controller through the Data register.
288:
289: A drive's motor must be on before the drive can be
290: selected. Units 0 and 1 cannot have their motor on
291: simultaneously; neither can units 2 and 3.
292:
293: A drive cannot be accessed until <head load time> has passed
294: since selecting the drive.
295:
296: A drive cannot be accessed until <head settle time> has
297: passed since an earlier access.
298:
299: Fields used in commands:
300:
301: Multi-Track: if this bit is set, both tracks of the
302: cylinder will be operated on.
303:
304: MFM/FM Mode: if this bit is set, MFM mode (double
305: density) is selected if it's implemented; if not, FM
306: mode (single density) is selected.
307:
308: Skip: when this bit is set, sectors with a deleted data
309: address mark will be skipped for READ DATA or accessed
310: for READ DELETED DATA.
311:
312: Head: one bit, 0 or 1.
313:
314: Drive Select: two bits to select drive 0 through 3.
315:
316: Cylinder: 7 bits selecting the cylinder.
317:
318: Sector: 4 bits giving the number of the first sector to
319: be accessed.
320:
321: Sector Size Code: the sector size is 2^(this value) *
322: 128. Sometimes forced to be 2, for 512-byte sectors.
323:
324: Final Sector of Track: 4 bits giving the final sector
325: number of current track.
326:
327: Gap Length: 8 bits giving the size of the gap between
328: sectors excluding the VC0 synchronization field.
329:
330: Data Length: if Sector Size Code is 0, the sector size
331: is 128 but this value says how many bytes are actually
332: transferred (extra bytes dropped on READs, extra bytes
333: zeroed on WRITEs). If Sector Size code is not 0
334: (sometimes it's forced nonzero), this value should be
335: 0xff.
336:
337: Sectors per Track: 4 bits giving the number of sectors
338: per cylinder to be initialized by a FORMAT.
339:
340: Data Pattern: 8 bits giving the pattern to be written in
341: each sector data field during a FORMAT.
342:
343: Step Rate Interval: 4 bits. The time between step
344: pulses. From .5 to 8ms in .5ms increments at 1Mb data
345: rate. See the SPECIFY command.
346:
347: Head Unload Time: 4 bits. The time from the end of a
348: read or write until the head is unloaded. 0 to 480ms in
349: 32ms increments. See the SPECIFY command.
350:
351: Head Load Time: 7 bits. The time from loading the head
352: until starting the read or write operation. 4 to 512ms
353: in 4ms increments. See the SPECIFY command.
354:
355: Non-DMA Mode Flag: 0 = DMA mode, 1 = host is interrupted
356: for each data transfer.
357:
358: New Cylinder Number: 7 bits giving the desired cylinder
359: number.
360:
361: The commands are given below. For each commands, the bytes
362: that must be written to the controller are listed. When the
363: command is finished (after an interrupt for most commands)
364: the further listed bytes MUST be read from the controller.
365:
366: READ DATA - move sector from diskette to memory via DMA.
367: Heads are automatically loaded and unloaded.
368:
369: WRITE Multi-Track, MFM/FM Mode, Skip, 00110
370: WRITE 00000, Head, Drive Select
371: WRITE Cylinder
372: WRITE Head
373: WRITE Sector
374: WRITE Sector Size Code
375: WRITE Final Sector of Track
376: WRITE Gap Length
377: WRITE Data Length
378:
379: <interrupt>
380:
381: READ Status Register 0
382: READ Status Register 1
383: READ Status Register 2
384: READ Cylinder
385: READ Head
386: READ Sector
387: READ Sector Size Code
388:
389: READ DELETED DATA - same as READ DATA, but only sectors with
390: the deleted data address mark are read.
391:
392: WRITE Multi-Track, MFM/FM Mode, Skip, 01100
393: WRITE 00000, Head, Drive Select
394: WRITE Cylinder
395: WRITE Head
396: WRITE Sector
397: WRITE Sector Size Code
398: WRITE Final Sector of Track
399: WRITE Gap Length
400: WRITE Data Length
401:
402: <interrupt>
403:
404: READ Status Register 0
405: READ Status Register 1
406: READ Status Register 2
407: READ Cylinder
408: READ Head
409: READ Sector
410: READ Sector Size Code
411:
412: READ TRACK - same as READ DATA, but all sectors from the index
413: mark to the "end of track" sector are read.
414:
415: WRITE 0, MFM/FM Mode, 000010
416: WRITE 00000, Head, Drive Select
417: WRITE Cylinder
418: WRITE Head
419: WRITE Sector
420: WRITE Sector Size Code
421: WRITE Final Sector of Track
422: WRITE Gap Length
423: WRITE Data Length
424:
425: <interrupt>
426:
427: READ Status Register 0
428: READ Status Register 1
429: READ Status Register 2
430: READ Cylinder
431: READ Head
432: READ Sector
433: READ Sector Size Code
434:
435: WRITE DATA - move sector from memory to diskette via DMA.
436: Heads are automatically loaded and unloaded.
437:
438: WRITE Multi-Track, MFM/FM Mode, 000101
439: WRITE 00000, Head, Drive Select
440: WRITE Cylinder
441: WRITE Head
442: WRITE Sector
443: WRITE Sector Size Code
444: WRITE Final Sector of Track
445: WRITE Gap Length
446: WRITE Data Length
447:
448: <interrupt>
449:
450: READ Status Register 0
451: READ Status Register 1
452: READ Status Register 2
453: READ Cylinder
454: READ Head
455: READ Sector
456: READ Sector Size Code
457:
458:
459: WRITE DELETED DATA - same as WRITE DATA, except a deleted
460: data address mark is written at the beginning of the data
461: field instead of the normal data address mark.
462:
463: WRITE Multi-Track, MFM/FM Mode, 001001
464: WRITE 00000, Head, Drive Select
465: WRITE Cylinder
466: WRITE Head
467: WRITE Sector
468: WRITE Sector Size Code
469: WRITE Final Sector of Track
470: WRITE Gap Length
471: WRITE Data Length
472:
473: <interrupt>
474:
475: READ Status Register 0
476: READ Status Register 1
477: READ Status Register 2
478: READ Cylinder
479: READ Head
480: READ Sector
481: READ Sector Size Code
482:
483: READ ID - the first ID field is read, and the status registers
484: are updated.
485:
486: WRITE 0, MFM/FM Mode, 001010
487: WRITE 00000, Head, Drive Select
488:
489: <interrupt>
490:
491: READ Status Register 0
492: READ Status Register 1
493: READ Status Register 2
494: READ Cylinder
495: READ Head
496: READ Sector
497: READ Sector Size Code
498:
499: FORMAT TRACK - the selected track is formatted from index to
500: "end of track" sector with address marks, ID fields, data
501: fields and field gaps. The data field is filled with the
502: specified pattern. The ID field data is specified by the host
503: *for each sector*.
504:
505: The DMA must be set up to send four bytes for each sector to
506: be formatted. The bytes are Cylinder, Head, Sector, and Sector
507: Size Code.
508:
509: WRITE 0, MFM/FM Mode, 001101
510: WRITE 00000, Head, Drive Select
511: WRITE Sector Size Code
512: WRITE Sectors per Track
513: WRITE Gap Length
514: WRITE Data Pattern
515:
516: <interrupt>
517:
518: READ Status Register 0
519: READ Status Register 1
520: READ Status Register 2
521: READ Undefined
522: READ Undefined
523: READ Undefined
524: READ Undefined
525:
526: RECALIBRATE - the heads are stepped to track 0. But note
527: that some controllers give up before reaching track 0, so it
528: might be necessary to RECALIBRATE more than once. All
529: drives must be RECALIBRATEd at initialization time. There
530: are no result registers, so the ISR should issue a SENSE
531: INTERRUPT STATUS command - which will result in two result
532: registers.
533:
534: WRITE 00000111
535: WRITE 000000, Drive Select
536:
537: <interrupt>
538:
539: SENSE INTERRUPT STATUS - the interrupt level is cleared, and
540: the controller status is returned.
541:
542: WRITE 00001000
543:
544: READ Status Register 0
545: READ Cylinder
546:
547: SPECIFY - the head load and unload rates, the drive step rate,
548: and the DMA data transfer mode are set.
549:
550: WRITE 00000011
551: WRITE Step Rate Interval, Head Unload Time
552: WRITE Head Load Time, Non-DMA Mode Flag
553:
554: SENSE DRIVE STATUS - the status of the selected drive is
555: returned.
556:
557: WRITE 00000100
558: WRITE 00000, Head, Drive Select
559:
560: READ Status Register 3
561:
562: SEEK - the selected drive is stepped to the new cylinder.
563: Seeks generally must be explicit, but on some controllers
564: can be made implicit via the CONFIGURE command. When not
565: implicit, READs and WRITEs should be preceded by SEEK, SENSE
566: INTERRUPT STATUS, and READ ID. There are no result
567: registers, so the ISR should issue a SENSE INTERRUPT STATUS
568: command - which does have two result registers.
569:
570: WRITE 00001111
571: WRITE 00000, Head, Drive Select
572: WRITE New Cylinder Number
573:
574: <interrupt>
575:
576: Commands not always implemented:
577:
578: Any command not implemented by a controller will result in
579: Status Register 0 returning x80 - "invalid command".
580:
581: The following commands are implemented by some controllers,
582: but not by all of the ones studied:
583:
584: Scan Equal
585: Scan Low or Equal
586: Scan High or Equal
587: Verify
588: Version
589: Configure
590: Relative Seek
591: Dump Registers
592: Perpendicular Mode
593:
594:
595: Data structures:
596:
597: For each floppy controller in the system (there's seldom more
598: than one) a controller data area is allocated. This area holds
599: all information about the controller, and all information common
600: to all of the drives attached to it. It has the following
601: fields:
602:
603: FifoBuffer[10] - data is sent to and received from the
604: controller via a FIFO port. A single routine,
605: FlIssueCommand(), is used to send the command and
606: parameters, and receive the result bytes. Before calling
607: FlIssueCommand(), the parameters should be placed into the
608: FifoBuffer; and after the command, the result bytes can be
609: read from the buffer. Note that for commands with a result
610: phase, the first result byte is read into the buffer by the
611: ISR. For commands without a result phase, the ISR writes a
612: SENSE INTERRUPT STATUS command, which means that *that*
613: command's result bytes will have to be read by
614: FlIssueCommand().
615:
616: InterruptDelay - set to a few seconds. When we're waiting
617: for an interrupt, we use this as a time-out value.
618:
619: Minimum10msDelay - set to 10 milliseconds, which is the
620: smallest unit of time that the floppy thread can block. Used
621: when blocking to wait for the controller to become ready to
622: transfer bytes through the FIFO.
623:
624: ListEntry - the list of requests for the floppy driver to
625: process. The dispatch routines add requests to the tail of
626: the list, and the floppy thread takes them off at the head.
627: In some cases of hardware failure, the floppy thread will
628: reinsert a request at the head of the list to try the packet
629: again.
630:
631: InterruptEvent - the event that is waited on when we're
632: expecting the controller to interrupt. It should be reset
633: before programming the controller, and set in the DPC that
634: is queued by the ISR.
635:
636: AllocateAdapterChannelEvent - the event that is waited on
637: when we're allocating a DMA adapter channel. It should be
638: reset before requesting the adapter, and set by the DPC that
639: is queued by the IO system when the adapter channel is
640: available.
641:
642: RequestSemaphore - the semaphore that the floppy thread waits
643: on. It should be released by the dispatch routines whenever
644: they add a request to the list. Note that it can also be
645: released when the thread is supposed to terminate; see
646: "UnloadingDriver".
647:
648: TimerSpinLock - a spinlock that is used to protect access to
649: "MotorTimer" and the DriveControl register, since they are
650: accessed by FloppyMotorOffDpc() as well as by routines in
651: the floppy thread.
652:
653: ListSpinLock - a spinlock that is allocated and used when
654: manipulating the list of requests for the floppy thread in
655: an atomic fashion (via the ExInterlocked* routines).
656:
657: InterruptObject - a pointer to an interrupt object; it must
658: be passed to IoConnectInterrupt.
659:
660: MapRegisterBase - the base address of the map registers.
661: Whenever an adapter channel is allocated, this value is passed
662: to our DPC. It's stored in the controller object so it can
663: be used when we call IoMapTransfer() and
664: IoFlushAdapterBuffers().
665:
666: IoBuffer - this driver always needs to allocate at least a
667: page to format floppies. On systems where there might not
668: be enough map registers to map the largest possible transfer
669: (the size of the largest supported track on the system), a
670: contiguous buffer of that size is allocated. Transfers for
671: which there aren't enough map registers are copied to or from
672: this buffer, since it is contiguous.
673:
674: IoBufferMdl - an MDL (memory descriptor list) to describe
675: "IoBuffer". Used to lock the pages, flush the buffer, etc.
676:
677: AdapterObject - an object obtained from HalGetAdapter() that
678: must be used when allocating a DMA adapter channel.
679:
680: CurrentDeviceObject - set to the device object in question
681: whenever an interrupt is expected. This aids debugging and
682: lets the ISR know whether an interrupt was expected or not.
683:
684: DriverObject - We keep a pointer around to the driver object
685: so that we can log an error if the controller object. The reason
686: we don't use the CurrentDeviceObject is that we may not have one
687: when we get around to logging the error.
688:
689: ControllerAddress - the virtual or I/O space address of the
690: base of the floppy controller, which is obtained from
691: configuration management.
692:
693: LastDisketteExtension - this value is used with
694: CreatedArtificialDrive, below, to decide when to return an
695: error. If the system only has one drive, it uses this field
696: to determine whether the device object describing the drive
697: has changed, so it knows when to return an error so the user
698: will be prompted to insert the other diskette.
699:
700: IoBufferSize - the size of "IoBuffer"; it is either a single
701: page (if there's plenty of map registers) or the size of the
702: largest track supported by the drives in the system.
703:
704: IsrReentered - This is counter that is used to determine
705: if we are in a hang condition from the controller on a
706: level sensitive machine.
707:
708: MotorTimer - used to count how long the drive motor has been
709: on, to determine when to turn it off. At the end of every
710: operation, it's set to 3; MotorOffDpc() is called every
711: second to decrement it. When it reaches 0, the motor is
712: turned off. Whenever the motor doesn't need to be turned
713: off (ie the drive is in use, or already off) the value is
714: -1. Note that "3" is an upper boundary; the motor will be
715: turned off between 2 and 3 seconds after the last operation.
716:
717: SpanOfControllerAddress - Indicates the number of bytes
718: used by the controllers register set. This is only useful
719: when the device is being unloaded and the controller address
720: is being unmapped.
721:
722: LastDriveMediaType - every time FlDatarateSpecifyConfigure()
723: is called, this value is set to the DriveMediaType that it
724: configured the controller to handle. When FlStartDrive() is
725: preparing an operation, it checks to see if the current
726: drive/media combination is the same - if not,
727: FlDatarateSpecifyConfigure() must be called again.
728:
729: NumberOfMapRegisters - the number of map registers available
730: to this driver, obtained from HalGetAdapter(), and possibly
731: lowered to the maximum number needed. Each register allows
732: the driver to map a single page (or more if the pages are
733: contiguous, but that's only counted on when the driver
734: allocated the contiguous buffer itself). This value is used
735: to determine whether or not the driver needs to allocate a
736: contiguous buffer to accomodate a transfer the size of the
737: largest track, and it is passed to IoAllocateAdapterChannel().
738:
739: NumberOfDrives - the number of drives attached to this
740: controller, obtained from the configuration manager. This
741: is used when allocating device objects and resetting the
742: hardware.
743:
744: DriveControlImage - the image of the drive control register.
745: We must keep track of it since the register is read-only on
746: some systems. It should always be updated before writing to
747: the drive control register.
748:
749: ControllerConfigurable - indicates whether or not the
750: CONFIGURE command is available. Assumed to be TRUE, it's
751: set to FALSE if an attempt to issue the CONFIGURE command
752: fails. Controllers with the CONFIGURE command are configured
753: to SEEK implicitly.
754:
755: HardwareFailCount - this is only used in FlFinishOperation.
756: If an operation fails due to a hardware problem, we'll retry
757: a certain number of times, and this keeps track of how many
758: times we've retried.
759:
760: HardwareFailed - this Boolean is set to FALSE at
761: initialization time and when each packet starts (even if
762: it's a retry). Whenever a hardware problem is encountered,
763: it is set to TRUE. At initialization time, failure to
764: initialize the hardware on the first drive means we must try
765: again on subsequent drives - if we never succeed, the driver
766: is unloaded. For each packet, hardware errors mean we'll
767: reset the hardware and retry the packet until it succeeds or
768: we overrun HardwareFailCount.
769:
770: CommandHasResultPhase - whenever a command is issued,
771: FlIssueCommand() sets this to TRUE if the command will
772: return result bytes. FloppyInterruptService() uses this to
773: decide how to dismiss the interrupt. Note that the BUSY bit
774: in the STATUS register should give us this information, but
775: it's sometimes set when it shouldn't be.
776:
777: CreatedArtificialDrive - if there's only one drive in the
778: system, the initialization code will create a *two* device
779: objects to describe it, and set this to TRUE. Whenever a
780: drive is accessed, if this is TRUE and the device object
781: being used is different, an error is returned so the user
782: will be prompted to insert the other diskette.
783:
784: UnloadingDriver - set to TRUE when the driver is supposed to
785: unload itself; setting this and then signalling the request
786: semaphore tells the thread to terminate itself.
787:
788: MappedControllerAddress - Set to TRUE indicates that when
789: unloading the driver, the pointer to the device controller
790: base register should be unmapped.
791:
792: For each physical floppy drive, a device object is allocated so
793: that the I/O system can access the drive. Attached to each device
794: object is a diskette extension structure, which contains
795: information specific to the drive and the media in it. Each
796: diskette extension contains a pointer to the controller data area
797: for the controller that it's attached to. Fields in the structure:
798:
799: DeviceObject - a pointer to the device object to which this
800: diskette extension is appended.
801:
802: ControllerData - a pointer to the controller data area that
803: describes the controller this drive is attached to.
804:
805: DriveType - the type of the physical drive, as defined in
806: flo_data.h.
807:
808: BytesPerSector - the bytes per sector of the media that was
809: last identified in the drive. Used to validate access
810: requests in the dispatch routines.
811:
812: ByteCapacity - the total number of bytes on the media that
813: was last identified in the drive. Used to validate access
814: requests in the dispatch routines.
815:
816: MediaType - the last type of media identified in the drive
817: (or "Unknown") as defined in ntdddisk.h. This value is used
818: to determine whether other media values in the diskette
819: extension are valid, and whether or not
820: FlDetermineMediaType() needs to be called.
821:
822: DriveMediaType - the last drive/media combination value,
823: determined when the media in the drive was last identified.
824: This is used to index into the DriveMediaConstants table.
825:
826: DeviceUnit - the controller-relative diskette number, which
827: is needed for some controller commands.
828:
829: DriveOnValue - the value that must be written to the
830: Drive Control register to start up the drive in question.
831: It's the "DeviceUnit" plus a few bits.
832:
833: ArtificialVerifyRequired - if there's only one drive in the
834: system, the user is prompted to switch drives by returning
835: STATUS_NO_MEDIA_IN_DEVICE. At that time, this value is set
836: to TRUE, so that the next time STATUS_VERIFY_REQUIRED can be
837: returned, to tell the file system to clean out it's caches.
838:
839: The DriveMediaLimits table, which is read-only, tells the driver
840: which drive/media combinations are valid for a drive type. The
841: table is indexed by the drive type, and has LowestDriveMediaType
842: and HighestDriveMediaType fields. The drive/media types are
843: enumerated in ascending order, so the driver can start at the
844: highest possible combination and decrement the value until the
845: correct one is found (or it goes below the lowest valid
846: drive/media combination).
847:
848: The DriveMediaConstants table, which is read-only, tells the driver
849: values that it needs to use when communicating with the controller
850: given the drive and media type. The table is indexed by the
851: DriveMedia number (unique for each drive/media combination) and
852: has the following fields:
853:
854: MediaType - the type of media specified by this drive/media
855: combination. The drive type is stored in the diskette
856: extension, since it never changes.
857:
858: StepRateHeadUnloadTime - a combination value that is written
859: to the controller as part of the SPECIFY command. The step
860: rate is how fast the heads can be moved track-to-track, and
861: the head unload time is how long it takes for the heads to
862: be unloaded after a READ or WRITE.
863:
864: HeadLoadTime - a value that is written to the controller as
865: part of the SPECIFY command. The head load time is how long
866: it takes the heads to stabilize after a SEEK before a READ
867: or WRITE can be initiated.
868:
869: MotorOffTime - not used by this driver, but included to keep
870: the table complete.
871:
872: SectorLengthCode - a code number that specifies the sector
873: size. The sector size is 2 to the "code" power, times 128.
874: So 0 means 128 bytes, 1 means 256, 2 means 512, etc. This
875: number is needed to pass to the controller for several
876: commands.
877:
878: BytesPerSector - the bytes per sector, which can be
879: determined from SectorLengthCode. Included as a separate
880: field for simplicity and speed.
881:
882: SectorsPerTrack - the number of sectors on a track (one head
883: of a cylinder).
884:
885: ReadWriteGapLength - the space between sectors, not
886: including the synchronization field. Used for READ and
887: WRITE commands.
888:
889: FormatGapLength - gap length passed to the FORMAT command.
890:
891: FormatFillCharacter - passed to the FORMAT command; this
892: byte will be used to fill the data fields on the disk.
893:
894: HeadSettleTime - the amount of time, in milliseconds, that
895: the driver must wait after performing a seek.
896:
897: MotorSettleTimeRead - the amount of time, in milliseconds,
898: that the driver must wait for the drive to spin up before
899: performing a READ.
900:
901: MotorSettleTimeWrite - the amount of time, in milliseconds,
902: that the driver must wait for the drive to spin up before
903: performing a WRITE. Note that WRITEs are more picky about
904: stable rotation speeds, so the drive must always spin up for
905: a longer than it would for a READ.
906:
907: MaximumTrack - the number of the highest track, or cylinder
908: on disk (zero-based).
909:
910: CylinderShift - normally 0, so it does nothing. This field
911: is used as a shift for the cylinder number before a SEEK
912: command. This is because of a hardware bug; 1.2Mb drives
913: don't seek the proper distance for low-density media, so for
914: those drive/media combinations this value is 1.
915:
916: DataTransferRate - the number written to the Datarate
917: register before accessing the media.
918:
919: NumberOfHeads - number of heads on the media, always 1 or 2
920: for floppies.
921:
922: DataLength - always 0xff, this value must be given to the
923: controller for a READ or WRITE command.
924:
925: The CommandTable, which is read-only, tells the driver how many
926: bytes it has to send and receive when issuing a command to the
927: controller. It is indexed by the command itself (minus any extra
928: bits, like COMMND_MFM) and has the following fields:
929:
930: NumberOfParameters - the number of parameter bytes that must
931: be sent along with this command.
932:
933: FirstResultByte - if the command has a result phase, then the
934: ISR reads the first byte so this value is 1 (meaning that the
935: 0th byte has already been read). If there is no result phase,
936: then the ISR must give a SENSE INTERRUPT STATUS command, and
937: this value is 0.
938:
939: NumberOfResultBytes - the number of bytes that must be read
940: from the controller after this command. For commands with
941: a result phase, this is the number of bytes returned minus
942: one (which was read by the ISR); for commands without a result
943: phase, this is "2" since that many bytes are returned by the
944: SENSE INTERRUPT STATUS command that is issued by the ISR.
945:
946: InterruptExpected - a Boolean that indicates whether or not
947: this command will give an interrupt.
948:
949: AlwaysImplemented - a Boolean that indicates whether or not
950: this command will always work. The CONFIGURE command, for
951: example, is useful but not always available. This helps to
952: determine the correct course of action when the controller
953: returns an error.
954:
955: Hardware quirks:
956:
957: Many controllers will only step 77 tracks on a recalibrate
958: command. But many drives have more tracks than that, so two
959: recalibrates are sometimes needed.
960:
961: When a 40-track diskette is in a 1.2Mb drive, the cylinder
962: number must be *doubled* before seeking. The number returned by
963: the seek will be the fake number, but the number returned by a
964: READ ID will be the correct cylinder. This makes implied SEEKs
965: impossible on low-density 5.25" media.
966:
967: Some machines will give an unexpected interrupt during a
968: controller reset unless bit 2 of the drive control register is
969: set in BOTH of the bytes that are written to the register.
970:
971: On fast machines, the BUSY bit is sometimes set in the main
972: status register even though the command doesn't have a result
973: phase and the command is obviously finished (as evidenced by the
974: fact that it interrupted; the ISR is where this problem shows
975: up).
976:
977: On at least the NCR 8 processor machine, we have seen the driver's
978: system thread run before the floppy controller can start the
979: SENSE_INTERRUPT command. We have placed code in the ISR to spin
980: until the SENSE command starts. (Actually it will time
981: out after ISR_SENSE_RETRY_COUNT 1 microsecond stalls.)
982:
983: --*/
984:
985: //
986: // Include files.
987: //
988:
989: #include "ntddk.h" // various NT definitions
990: #include "ntdddisk.h" // disk device driver I/O control codes
991: #include <flo_data.h> // this driver's data declarations
992:
993:
994: //
995: // This is the actual definition of FloppyDebugLevel.
996: // Note that it is only defined if this is a "debug"
997: // build.
998: //
999: #if DBG
1000: extern ULONG FloppyDebugLevel = 0;
1001: #endif
1002:
1003: #ifdef ALLOC_PRAGMA
1004: #pragma alloc_text(init,DriverEntry)
1005: #pragma alloc_text(init,FlConfigCallBack)
1006: #pragma alloc_text(init,FlGetConfigurationInformation)
1007: #pragma alloc_text(init,FlReportResources)
1008: #pragma alloc_text(init,FlInitializeController)
1009: #pragma alloc_text(init,FlInitializeDrive)
1010: #pragma alloc_text(init,FlGetControllerBase)
1011: #endif
1012:
1013: // #define KEEP_COUNTERS 1
1014:
1015: #ifdef KEEP_COUNTERS
1016: ULONG FloppyUsedSeek = 0;
1017: ULONG FloppyNoSeek = 0;
1018: ULONG FloppyUsedBuffer = 0;
1019: ULONG FloppyInterrupts = 0;
1020: ULONG FloppySpurious = 0;
1021: ULONG FloppyIntrBitSet = 0;
1022: ULONG FloppyDPCs = 0;
1023: ULONG FloppyThreadWake = 0;
1024: LARGE_INTEGER FloppyIntrDelay = { 0, 0 };
1025: LARGE_INTEGER FloppyDPCDelay = { 0, 0 };
1026: LARGE_INTEGER FloppyThreadDelay = { 0, 0 };
1027: LARGE_INTEGER FloppyFromIntrDelay = { 0, 0 };
1028: LARGE_INTEGER FloppyThreadTime = { 0, 0 };
1029: LARGE_INTEGER FloppyIntrTime = { 0, 0 };
1030: LARGE_INTEGER FloppyEndIntrTime = { 0, 0 };
1031: LARGE_INTEGER FloppyDPCTime = { 0, 0 };
1032: #endif
1033:
1034:
1035: NTSTATUS
1036: DriverEntry(
1037: IN PDRIVER_OBJECT DriverObject,
1038: IN PUNICODE_STRING RegistryPath
1039: )
1040:
1041: /*++
1042:
1043: Routine Description:
1044:
1045: This routine is the driver's entry point, called by the I/O system
1046: to load the driver. This routine can be called any number of times,
1047: as long as the IO system and the configuration manager conspire to
1048: give it an unmanaged controller to support at each call. It could
1049: also be called a single time and given all of the controllers at
1050: once.
1051:
1052: It initializes the passed-in driver object, calls the configuration
1053: manager to learn about the devices that it is to support, and for
1054: each controller to be supported it calls a routine to initialize the
1055: controller (and all drives attached to it).
1056:
1057: Arguments:
1058:
1059: DriverObject - a pointer to the object that represents this device
1060: driver.
1061:
1062: Return Value:
1063:
1064: If we successfully initialize at least one drive, STATUS_SUCCESS is
1065: returned.
1066:
1067: If we don't (because the configuration manager returns an error, or
1068: the configuration manager says that there are no controllers or
1069: drives to support, or no controllers or drives can be successfully
1070: initialized), then the last error encountered is propogated.
1071:
1072: --*/
1073:
1074: {
1075: PCONFIG_DATA configData; // pointer to config mgr's returned data
1076: NTSTATUS ntStatus;
1077: UCHAR controllerNumber;
1078: BOOLEAN partlySuccessful = FALSE; // TRUE if any controller init'd properly
1079:
1080: //
1081: // We use this to query into the registry as to whether we
1082: // should break at driver entry.
1083: //
1084: RTL_QUERY_REGISTRY_TABLE paramTable[3];
1085: ULONG zero = 0;
1086: ULONG debugLevel = 0;
1087: ULONG shouldBreak = 0;
1088: PWCHAR path;
1089:
1090: UNREFERENCED_PARAMETER(RegistryPath);
1091:
1092: //
1093: // Since the registry path parameter is a "counted" UNICODE string, it
1094: // might not be zero terminated. For a very short time allocate memory
1095: // to hold the registry path zero terminated so that we can use it to
1096: // delve into the registry.
1097: //
1098: // NOTE NOTE!!!! This is not an architected way of breaking into
1099: // a driver. It happens to work for this driver because the author
1100: // likes to do things this way.
1101: //
1102:
1103: if (path = ExAllocatePool(
1104: PagedPool,
1105: RegistryPath->Length+sizeof(WCHAR)
1106: )) {
1107:
1108: RtlZeroMemory(
1109: ¶mTable[0],
1110: sizeof(paramTable)
1111: );
1112: RtlZeroMemory(
1113: path,
1114: RegistryPath->Length+sizeof(WCHAR)
1115: );
1116: RtlMoveMemory(
1117: path,
1118: RegistryPath->Buffer,
1119: RegistryPath->Length
1120: );
1121: paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
1122: paramTable[0].Name = L"BreakOnEntry";
1123: paramTable[0].EntryContext = &shouldBreak;
1124: paramTable[0].DefaultType = REG_DWORD;
1125: paramTable[0].DefaultData = &zero;
1126: paramTable[0].DefaultLength = sizeof(ULONG);
1127: paramTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
1128: paramTable[1].Name = L"DebugLevel";
1129: paramTable[1].EntryContext = &debugLevel;
1130: paramTable[1].DefaultType = REG_DWORD;
1131: paramTable[1].DefaultData = &zero;
1132: paramTable[1].DefaultLength = sizeof(ULONG);
1133:
1134: if (!NT_SUCCESS(RtlQueryRegistryValues(
1135: RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
1136: path,
1137: ¶mTable[0],
1138: NULL,
1139: NULL
1140: ))) {
1141:
1142: shouldBreak = 0;
1143: debugLevel = 0;
1144:
1145: }
1146:
1147: }
1148:
1149: //
1150: // We don't need that path anymore.
1151: //
1152:
1153: if (path) {
1154:
1155: ExFreePool(path);
1156:
1157: }
1158:
1159: #if DBG
1160: FloppyDebugLevel = debugLevel;
1161: #endif
1162:
1163: if (shouldBreak) {
1164:
1165: DbgBreakPoint();
1166:
1167: }
1168:
1169: FloppyDump(
1170: FLOPSHOW,
1171: ("Floppy: DriverEntry...\n")
1172: );
1173:
1174: //
1175: // Ask configuration manager for information on the hardware that
1176: // we're supposed to support.
1177: //
1178:
1179: ntStatus = FlGetConfigurationInformation( &configData );
1180:
1181: //
1182: // If FlGetConfigurationInformation() failed, just exit and propogate
1183: // the error. If it said that there are no controllers to support,
1184: // return an error.
1185: // Otherwise, try to init the controllers. If at least one succeeds,
1186: // return STATUS_SUCCESS, otherwise return the last error.
1187: //
1188:
1189: if ( NT_SUCCESS( ntStatus ) ) {
1190:
1191: //
1192: // Call FlInitializeController() for each controller (and its
1193: // attached drives) that we're supposed to support.
1194: //
1195: // Return success if we successfully initialize at least one
1196: // device; propogate error otherwise. Set an error first in
1197: // case there aren't any controllers.
1198: //
1199:
1200: ntStatus = STATUS_NO_SUCH_DEVICE;
1201:
1202: for ( controllerNumber = 0;
1203: controllerNumber < configData->NumberOfControllers;
1204: controllerNumber++ ) {
1205:
1206: ntStatus = FlInitializeController(
1207: configData,
1208: controllerNumber,
1209: DriverObject );
1210:
1211: if ( NT_SUCCESS( ntStatus ) ) {
1212:
1213: partlySuccessful = TRUE;
1214: }
1215: }
1216:
1217: if ( partlySuccessful ) {
1218:
1219: ntStatus = STATUS_SUCCESS;
1220:
1221: //
1222: // Initialize the driver object with this driver's entry points.
1223: //
1224:
1225: DriverObject->MajorFunction[IRP_MJ_CREATE] =
1226: FloppyDispatchCreateClose;
1227: DriverObject->MajorFunction[IRP_MJ_CLOSE] =
1228: FloppyDispatchCreateClose;
1229: DriverObject->MajorFunction[IRP_MJ_READ] = FloppyDispatchReadWrite;
1230: DriverObject->MajorFunction[IRP_MJ_WRITE] = FloppyDispatchReadWrite;
1231: DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] =
1232: FloppyDispatchDeviceControl;
1233: }
1234: }
1235:
1236: if ( !NT_SUCCESS( ntStatus ) ) {
1237:
1238: FloppyDump(
1239: FLOPDBGP,
1240: ("Floppy: exiting with error %lx\n", ntStatus)
1241: );
1242: }
1243:
1244: if (configData) {
1245:
1246: ExFreePool(configData);
1247:
1248: }
1249:
1250: return ntStatus;
1251: }
1252:
1253: NTSTATUS
1254: FlConfigCallBack(
1255: IN PVOID Context,
1256: IN PUNICODE_STRING PathName,
1257: IN INTERFACE_TYPE BusType,
1258: IN ULONG BusNumber,
1259: IN PKEY_VALUE_FULL_INFORMATION *BusInformation,
1260: IN CONFIGURATION_TYPE ControllerType,
1261: IN ULONG ControllerNumber,
1262: IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation,
1263: IN CONFIGURATION_TYPE PeripheralType,
1264: IN ULONG PeripheralNumber,
1265: IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation
1266: )
1267:
1268: /*++
1269:
1270: Routine Description:
1271:
1272: This routine is used to acquire all of the configuration
1273: information for each floppy disk controller and the
1274: peripheral driver attached to that controller.
1275:
1276: Arguments:
1277:
1278: Context - Pointer to the confuration information we are building
1279: up.
1280:
1281: PathName - unicode registry path. Not Used.
1282:
1283: BusType - Internal, Isa, ...
1284:
1285: BusNumber - Which bus if we are on a multibus system.
1286:
1287: BusInformation - Configuration information about the bus. Not Used.
1288:
1289: ControllerType - Should always be DiskController.
1290:
1291: ControllerNumber - Which controller if there is more than one
1292: controller in the system.
1293:
1294: ControllerInformation - Array of pointers to the three pieces of
1295: registry information.
1296:
1297: PeripheralType - Should always be FloppyDiskPeripheral.
1298:
1299: PeripheralNumber - Which floppy if this controller is maintaining
1300: more than one.
1301:
1302: PeripheralInformation - Arrya of pointers to the three pieces of
1303: registry information.
1304:
1305: Return Value:
1306:
1307: STATUS_SUCCESS if everything went ok, or STATUS_INSUFFICIENT_RESOURCES
1308: if it couldn't map the base csr or acquire the adapter object, or
1309: all of the resource information couldn't be acquired.
1310:
1311: --*/
1312:
1313: {
1314:
1315: //
1316: // So we don't have to typecast the context.
1317: //
1318: PCONFIG_DATA config = Context;
1319:
1320: //
1321: // Simple iteration variable.
1322: //
1323: ULONG i;
1324:
1325: //
1326: // This boolean will be used to denote whether we've seen this
1327: // controller before.
1328: //
1329: BOOLEAN newController;
1330:
1331: //
1332: // This will be used to denote whether we even have room
1333: // for a new controller.
1334: //
1335: BOOLEAN outOfRoom;
1336:
1337: //
1338: // Iteration variable that will end up indexing to where
1339: // the controller information should be placed.
1340: //
1341: ULONG ControllerSlot;
1342:
1343: //
1344: // Short hand for referencing the particular controller config
1345: // information that we are building up.
1346: //
1347: PCONFIG_CONTROLLER_DATA controller;
1348:
1349: PCM_FULL_RESOURCE_DESCRIPTOR peripheralData;
1350:
1351: //
1352: // These three boolean will tell us whether we got all the
1353: // information that we needed.
1354: //
1355: BOOLEAN foundPort = FALSE;
1356: BOOLEAN foundInterrupt = FALSE;
1357: BOOLEAN foundDma = FALSE;
1358:
1359: ASSERT(ControllerType == DiskController);
1360: ASSERT(PeripheralType == FloppyDiskPeripheral);
1361:
1362: //
1363: // Check if the infprmation from the registry for this device
1364: // is valid.
1365: //
1366:
1367: if (!(((PUCHAR)PeripheralInformation[IoQueryDeviceConfigurationData]) +
1368: PeripheralInformation[IoQueryDeviceConfigurationData]->DataLength) ||
1369:
1370: !(((PUCHAR)ControllerInformation[IoQueryDeviceConfigurationData]) +
1371: ControllerInformation[IoQueryDeviceConfigurationData]->DataOffset)) {
1372:
1373: ASSERT(FALSE);
1374: return STATUS_INVALID_PARAMETER;
1375:
1376: }
1377:
1378: peripheralData = (PCM_FULL_RESOURCE_DESCRIPTOR)
1379: (((PUCHAR)PeripheralInformation[IoQueryDeviceConfigurationData]) +
1380: PeripheralInformation[IoQueryDeviceConfigurationData]->DataOffset);
1381:
1382: //
1383: // Loop through the "slots" that we have for a new controller.
1384: // Determine if this is a controller that we've already seen,
1385: // or a new controller.
1386: //
1387:
1388: outOfRoom = TRUE;
1389: for (
1390: ControllerSlot = 0;
1391: ControllerSlot < MAXIMUM_CONTROLLERS_PER_MACHINE;
1392: ControllerSlot++
1393: ) {
1394:
1395: if (config->Controller[ControllerSlot].ActualControllerNumber == -1) {
1396:
1397: newController = TRUE;
1398: outOfRoom = FALSE;
1399: config->Controller[ControllerSlot].ActualControllerNumber =
1400: ControllerNumber;
1401: config->NumberOfControllers++;
1402: break;
1403:
1404: } else if (config->Controller[ControllerSlot].ActualControllerNumber
1405: == (LONG)ControllerNumber) {
1406:
1407: newController = FALSE;
1408: outOfRoom = FALSE;
1409: break;
1410:
1411: }
1412:
1413: }
1414:
1415: if (outOfRoom) {
1416:
1417: //
1418: // Just return and ignore the controller.
1419: //
1420:
1421: return STATUS_SUCCESS;
1422:
1423: }
1424:
1425: //
1426: // Make sure we have room for this floppy disk peripheral.
1427: //
1428:
1429: if (config->Controller[ControllerSlot].NumberOfDrives >=
1430: MAXIMUM_DISKETTES_PER_CONTROLLER) {
1431:
1432: return STATUS_SUCCESS;
1433:
1434: }
1435:
1436: controller = &config->Controller[ControllerSlot];
1437:
1438: if (newController) {
1439:
1440: PCM_FULL_RESOURCE_DESCRIPTOR controllerData =
1441: (PCM_FULL_RESOURCE_DESCRIPTOR)
1442: (((PUCHAR)ControllerInformation[IoQueryDeviceConfigurationData]) +
1443: ControllerInformation[IoQueryDeviceConfigurationData]->DataOffset);
1444:
1445: //
1446: // We have the pointer. Save off the interface type and
1447: // the busnumber for use when we call the Hal and the
1448: // Io System.
1449: //
1450:
1451: controller->InterfaceType = BusType;
1452: controller->BusNumber = BusNumber;
1453: controller->SharableVector = TRUE;
1454: controller->SaveFloatState = FALSE;
1455:
1456: //
1457: // We need to get the following information out of the partial
1458: // resource descriptors.
1459: //
1460: // The irql and vector.
1461: //
1462: // The dma channel.
1463: //
1464: // The base address and span covered by the floppy controllers
1465: // registers.
1466: //
1467: // It is not defined how these appear in the partial resource
1468: // lists, so we will just loop over all of them. If we find
1469: // something we don't recognize, we drop that information on
1470: // the floor. When we have finished going through all the
1471: // partial information, we validate that we got the above
1472: // three.
1473: //
1474:
1475: for (
1476: i = 0;
1477: i < controllerData->PartialResourceList.Count;
1478: i++
1479: ) {
1480:
1481: PCM_PARTIAL_RESOURCE_DESCRIPTOR partial =
1482: &controllerData->PartialResourceList.PartialDescriptors[i];
1483:
1484: switch (partial->Type) {
1485:
1486: case CmResourceTypePort: {
1487:
1488: foundPort = TRUE;
1489:
1490: //
1491: // Save of the pointer to the partial so
1492: // that we can later use it to report resources
1493: // and we can also use this later in the routine
1494: // to make sure that we got all of our resources.
1495: //
1496:
1497: controller->SpanOfControllerAddress =
1498: partial->u.Port.Length;
1499: controller->OriginalBaseAddress =
1500: partial->u.Port.Start;
1501: controller->ResourcePortType =
1502: !!partial->Flags;
1503: controller->ControllerBaseAddress =
1504: FlGetControllerBase(
1505: BusType,
1506: BusNumber,
1507: partial->u.Port.Start,
1508: controller->SpanOfControllerAddress,
1509: (BOOLEAN)!!partial->Flags,
1510: &controller->MappedAddress
1511: );
1512:
1513: if (!controller->ControllerBaseAddress) {
1514:
1515: return STATUS_INSUFFICIENT_RESOURCES;
1516:
1517: }
1518:
1519: break;
1520: }
1521: case CmResourceTypeInterrupt: {
1522:
1523: foundInterrupt = TRUE;
1524: if (partial->Flags & CM_RESOURCE_INTERRUPT_LATCHED) {
1525:
1526: controller->InterruptMode = Latched;
1527:
1528: } else {
1529:
1530: controller->InterruptMode = LevelSensitive;
1531:
1532: }
1533:
1534: controller->OriginalIrql = partial->u.Interrupt.Level;
1535: controller->OriginalVector = partial->u.Interrupt.Vector;
1536: controller->ControllerVector =
1537: HalGetInterruptVector(
1538: BusType,
1539: BusNumber,
1540: partial->u.Interrupt.Level,
1541: partial->u.Interrupt.Vector,
1542: &controller->ControllerIrql,
1543: &controller->ProcessorMask
1544: );
1545:
1546: break;
1547: }
1548: case CmResourceTypeDma: {
1549:
1550: DEVICE_DESCRIPTION deviceDesc = {0};
1551:
1552: foundDma = TRUE;
1553: controller->OriginalDmaChannel = partial->u.Dma.Channel;
1554: deviceDesc.Version = DEVICE_DESCRIPTION_VERSION;
1555: deviceDesc.DmaWidth = Width8Bits;
1556: deviceDesc.DemandMode = TRUE;
1557: deviceDesc.MaximumLength =
1558: DriveMediaConstants[NUMBER_OF_DRIVE_MEDIA_COMBINATIONS-1].
1559: BytesPerSector *
1560: DriveMediaConstants[NUMBER_OF_DRIVE_MEDIA_COMBINATIONS-1].
1561: SectorsPerTrack;
1562:
1563: //
1564: // Always ask for one more page than maximum transfer size.
1565: //
1566:
1567: deviceDesc.MaximumLength += PAGE_SIZE;
1568:
1569: deviceDesc.DmaChannel = partial->u.Dma.Channel;
1570: deviceDesc.InterfaceType = BusType;
1571: deviceDesc.DmaSpeed = TypeA;
1572: controller->AdapterObject =
1573: HalGetAdapter(
1574: &deviceDesc,
1575: &controller->NumberOfMapRegisters
1576: );
1577:
1578: if (!controller->AdapterObject) {
1579:
1580: return STATUS_INSUFFICIENT_RESOURCES;
1581:
1582: }
1583:
1584: break;
1585:
1586: }
1587: default: {
1588:
1589: break;
1590:
1591: }
1592:
1593: }
1594:
1595: }
1596:
1597: //
1598: // If we didn't get all the information then we return
1599: // insufficient resources.
1600: //
1601:
1602: if ((!foundPort) ||
1603: (!foundInterrupt) ||
1604: (!foundDma)) {
1605:
1606: return STATUS_INSUFFICIENT_RESOURCES;
1607:
1608: }
1609:
1610: }
1611:
1612: //
1613: // With Version 2.0 or greater for this resource list, we will get
1614: // the full int13 information for the drive. So get that if available.
1615: //
1616: // Otherwise, the only thing that we want out of the peripheral information
1617: // is the maximum drive capacity.
1618: //
1619:
1620: //
1621: // Drop any other information on the floor other then the
1622: // device specfic floppy information.
1623: //
1624:
1625: for (
1626: i = 0;
1627: i < peripheralData->PartialResourceList.Count;
1628: i++
1629: ) {
1630:
1631: PCM_PARTIAL_RESOURCE_DESCRIPTOR partial =
1632: &peripheralData->PartialResourceList.PartialDescriptors[i];
1633:
1634: if (partial->Type == CmResourceTypeDeviceSpecific) {
1635:
1636: //
1637: // Point to right after this partial. This will take
1638: // us to the beginning of the "real" device specific.
1639: //
1640:
1641: PCM_FLOPPY_DEVICE_DATA fDeviceData;
1642: UCHAR driveType;
1643: PDRIVE_MEDIA_CONSTANTS biosDriveMediaConstants =
1644: &(controller->BiosDriveMediaConstants[controller->NumberOfDrives]);
1645:
1646:
1647: fDeviceData = (PCM_FLOPPY_DEVICE_DATA)(partial + 1);
1648:
1649: //
1650: // Get the driver density
1651: //
1652:
1653: switch ( fDeviceData->MaxDensity ) {
1654:
1655: case 360:
1656:
1657: driveType = DRIVE_TYPE_0360;
1658:
1659: break;
1660:
1661:
1662: case 1200:
1663:
1664: driveType = DRIVE_TYPE_1200;
1665:
1666: break;
1667:
1668:
1669: case 1185:
1670:
1671: driveType = DRIVE_TYPE_1200;
1672:
1673: break;
1674:
1675: case 1423:
1676:
1677: driveType = DRIVE_TYPE_1440;
1678:
1679: break;
1680:
1681: case 1440:
1682:
1683: driveType = DRIVE_TYPE_1440;
1684:
1685: break;
1686:
1687: case 2880:
1688:
1689: driveType = DRIVE_TYPE_2880;
1690:
1691: break;
1692:
1693: default:
1694:
1695: FloppyDump(
1696: FLOPDBGP,
1697: ("Floppy: Bad DriveCapacity!\n"
1698: "------ density is %d\n",
1699: fDeviceData->MaxDensity)
1700: );
1701:
1702: driveType = DRIVE_TYPE_1200;
1703:
1704: FloppyDump(
1705: FLOPDBGP,
1706: ("Floppy: run a setup program to set the floppy\n"
1707: "------ drive type; assuming 1.2mb\n"
1708: "------ (type is %x)\n",fDeviceData->MaxDensity)
1709: );
1710:
1711: break;
1712:
1713: }
1714:
1715: controller->DriveType[controller->NumberOfDrives] = driveType;
1716:
1717: //
1718: // Pick up all the default from our own table and override
1719: // with the BIOS information
1720: //
1721:
1722: *biosDriveMediaConstants = DriveMediaConstants[
1723: DriveMediaLimits[driveType].HighestDriveMediaType];
1724:
1725: //
1726: // If the version is high enough, get the rest of the information.
1727: // DeviceSpecific information with a version >= 2 should have
1728: // this information
1729: //
1730:
1731: if (fDeviceData->Version >= 2) {
1732:
1733: // biosDriveMediaConstants->MediaType =
1734:
1735: biosDriveMediaConstants->StepRateHeadUnloadTime =
1736: fDeviceData->StepRateHeadUnloadTime;
1737:
1738: biosDriveMediaConstants->HeadLoadTime =
1739: fDeviceData->HeadLoadTime;
1740:
1741: biosDriveMediaConstants->MotorOffTime =
1742: fDeviceData->MotorOffTime;
1743:
1744: biosDriveMediaConstants->SectorLengthCode =
1745: fDeviceData->SectorLengthCode;
1746:
1747: // biosDriveMediaConstants->BytesPerSector =
1748:
1749: biosDriveMediaConstants->SectorsPerTrack =
1750: fDeviceData->SectorPerTrack;
1751:
1752: biosDriveMediaConstants->ReadWriteGapLength =
1753: fDeviceData->ReadWriteGapLength;
1754:
1755: biosDriveMediaConstants->FormatGapLength =
1756: fDeviceData->FormatGapLength;
1757:
1758: biosDriveMediaConstants->FormatFillCharacter =
1759: fDeviceData->FormatFillCharacter;
1760:
1761: biosDriveMediaConstants->HeadSettleTime =
1762: fDeviceData->HeadSettleTime;
1763:
1764: biosDriveMediaConstants->MotorSettleTimeRead =
1765: fDeviceData->MotorSettleTime * 1000 / 8;
1766:
1767: biosDriveMediaConstants->MotorSettleTimeWrite =
1768: fDeviceData->MotorSettleTime * 1000 / 8;
1769:
1770: biosDriveMediaConstants->MaximumTrack =
1771: fDeviceData->MaximumTrackValue;
1772:
1773: // biosDriveMediaConstants->CylinderShift =
1774:
1775: // NOTE CHICAGO does not use this value
1776: //
1777: //biosDriveMediaConstants->DataTransferRate =
1778: // fDeviceData->DataTransferRate;
1779:
1780: // biosDriveMediaConstants->NumberOfHeads =
1781:
1782: biosDriveMediaConstants->DataLength =
1783: fDeviceData->DataTransferLength;
1784:
1785: }
1786:
1787: }
1788:
1789: }
1790:
1791: controller->NumberOfDrives++;
1792: controller->OkToUseThisController = TRUE;
1793:
1794: return STATUS_SUCCESS;
1795: }
1796:
1797: NTSTATUS
1798: FlGetConfigurationInformation(
1799: OUT PCONFIG_DATA *ConfigData
1800: )
1801:
1802: /*++
1803:
1804: Routine Description:
1805:
1806: This routine is called by DriverEntry() to get information about the
1807: devices to be supported from configuration mangement and/or the
1808: hardware architecture layer (HAL).
1809:
1810: Arguments:
1811:
1812: ConfigData - a pointer to the pointer to a data structure that
1813: describes the controllers and the drives attached to them
1814:
1815: Return Value:
1816:
1817: Returns STATUS_SUCCESS unless there is no drive 0 or we didn't get
1818: any configuration information.
1819:
1820: --*/
1821:
1822: {
1823:
1824: INTERFACE_TYPE InterfaceType;
1825: NTSTATUS Status;
1826: ULONG i;
1827:
1828: *ConfigData = ExAllocatePool(
1829: PagedPool,
1830: sizeof(CONFIG_DATA)
1831: );
1832:
1833: if (!*ConfigData) {
1834:
1835: return STATUS_INSUFFICIENT_RESOURCES;
1836:
1837: }
1838:
1839: //
1840: // Zero out the config structure and fill in the actual
1841: // controller numbers with -1's so that the callback routine
1842: // can recognize a new controller.
1843: //
1844:
1845: RtlZeroMemory(
1846: *ConfigData,
1847: sizeof(CONFIG_DATA)
1848: );
1849:
1850: for (
1851: i = 0;
1852: i < MAXIMUM_CONTROLLERS_PER_MACHINE;
1853: i++
1854: ) {
1855:
1856: (*ConfigData)->Controller[i].ActualControllerNumber = -1;
1857:
1858: }
1859:
1860: //
1861: // Go through all of the various bus types looking for
1862: // disk controllers. The disk controller sections of the
1863: // hardware registry only deal with the floppy drives.
1864: // The callout routine that can get called will then
1865: // look for information pertaining to a particular
1866: // device on the controller.
1867: //
1868:
1869: for (
1870: InterfaceType = 0;
1871: InterfaceType < MaximumInterfaceType;
1872: InterfaceType++
1873: ) {
1874:
1875: CONFIGURATION_TYPE Dc = DiskController;
1876: CONFIGURATION_TYPE Fp = FloppyDiskPeripheral;
1877:
1878: Status = IoQueryDeviceDescription(
1879: &InterfaceType,
1880: NULL,
1881: &Dc,
1882: NULL,
1883: &Fp,
1884: NULL,
1885: FlConfigCallBack,
1886: *ConfigData
1887: );
1888:
1889: if (!NT_SUCCESS(Status) && (Status != STATUS_OBJECT_NAME_NOT_FOUND)) {
1890:
1891: ExFreePool(*ConfigData);
1892: *ConfigData = NULL;
1893: return Status;
1894:
1895: }
1896:
1897: }
1898:
1899: //
1900: // Get a pointer to the Io system location that is keeping
1901: // a count of all the floppy devices on the system.
1902: //
1903:
1904: if ( IoGetConfigurationInformation() == NULL ) {
1905:
1906: FloppyDump(
1907: FLOPDBGP,
1908: ("Floppy: configuration information is NULL\n")
1909: );
1910: ExFreePool(*ConfigData);
1911: *ConfigData = NULL;
1912: return STATUS_INSUFFICIENT_RESOURCES;
1913: }
1914:
1915: (*ConfigData)->FloppyCount = &IoGetConfigurationInformation()->FloppyCount;
1916:
1917: return STATUS_SUCCESS;
1918: }
1919:
1920: BOOLEAN
1921: FlReportResources(
1922: IN PDRIVER_OBJECT DriverObject,
1923: IN PCONFIG_DATA ConfigData,
1924: IN UCHAR ControllerNumber
1925: )
1926:
1927: /*++
1928:
1929: Routine Description:
1930:
1931: This routine will build up a resource list using the
1932: data for this particular controller as well as all
1933: previous *successfully* configured controllers.
1934:
1935: N.B. This routine assumes that it called in controller
1936: number order.
1937:
1938: Arguments:
1939:
1940: DriverObject - a pointer to the object that represents this device
1941: driver.
1942:
1943: ConfigData - a pointer to the structure that describes the
1944: controller and the disks attached to it, as given to us by the
1945: configuration manager.
1946:
1947: ControllerNumber - which controller in ConfigData we are
1948: about to try to report.
1949:
1950: Return Value:
1951:
1952: TRUE if no conflict was detected, FALSE otherwise.
1953:
1954: --*/
1955:
1956: {
1957:
1958:
1959: ULONG sizeOfResourceList;
1960: ULONG numberOfFrds;
1961: ULONG i;
1962: PCM_RESOURCE_LIST resourceList;
1963: PCM_FULL_RESOURCE_DESCRIPTOR nextFrd;
1964:
1965: //
1966: // Loop through all of the controllers previous to this
1967: // controller. If the controllers previous to this one
1968: // didn't have a conflict, then accumulate the size of the
1969: // CM_FULL_RESOURCE_DESCRIPTOR associated with it.
1970: //
1971:
1972: for (
1973: i = 0,numberOfFrds = 0,sizeOfResourceList = 0;
1974: i <= ControllerNumber;
1975: i++
1976: ) {
1977:
1978: if (ConfigData->Controller[i].OkToUseThisController) {
1979:
1980: sizeOfResourceList += sizeof(CM_FULL_RESOURCE_DESCRIPTOR);
1981:
1982: //
1983: // The full resource descriptor already contains one
1984: // partial. Make room for three more.
1985: //
1986: // It will hold the irq "prd", the controller "csr" "prd" which
1987: // is actually in two pieces since we don't use one of the
1988: // registers, and the controller dma "prd".
1989: //
1990:
1991: sizeOfResourceList += 3*sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
1992: numberOfFrds++;
1993:
1994: }
1995:
1996: }
1997:
1998: //
1999: // Now we increment the length of the resource list by field offset
2000: // of the first frd. This will give us the length of what preceeds
2001: // the first frd in the resource list.
2002: //
2003:
2004: sizeOfResourceList += FIELD_OFFSET(
2005: CM_RESOURCE_LIST,
2006: List[0]
2007: );
2008:
2009: resourceList = ExAllocatePool(
2010: PagedPool,
2011: sizeOfResourceList
2012: );
2013:
2014: if (!resourceList) {
2015:
2016: return FALSE;
2017:
2018: }
2019:
2020: //
2021: // Zero out the field
2022: //
2023:
2024: RtlZeroMemory(
2025: resourceList,
2026: sizeOfResourceList
2027: );
2028:
2029: resourceList->Count = numberOfFrds;
2030: nextFrd = &resourceList->List[0];
2031:
2032: for (
2033: i = 0;
2034: numberOfFrds;
2035: i++
2036: ) {
2037:
2038: if (ConfigData->Controller[i].OkToUseThisController) {
2039:
2040: PCM_PARTIAL_RESOURCE_DESCRIPTOR partial;
2041:
2042: nextFrd->InterfaceType = ConfigData->Controller[i].InterfaceType;
2043: nextFrd->BusNumber = ConfigData->Controller[i].BusNumber;
2044:
2045: //
2046: // We are only going to report 4 items no matter what
2047: // was in the original.
2048: //
2049:
2050: nextFrd->PartialResourceList.Count = 4;
2051:
2052: //
2053: // Now fill in the port data. We don't wish to share
2054: // this port range with anyone
2055: //
2056:
2057: partial = &nextFrd->PartialResourceList.PartialDescriptors[0];
2058:
2059: partial->Type = CmResourceTypePort;
2060: partial->ShareDisposition = CmResourceShareShared;
2061: partial->Flags = (USHORT)ConfigData->Controller[i].ResourcePortType;
2062: partial->u.Port.Start =
2063: ConfigData->Controller[i].OriginalBaseAddress;
2064: partial->u.Port.Length = 6;
2065:
2066: partial++;
2067:
2068: partial->Type = CmResourceTypePort;
2069: partial->ShareDisposition = CmResourceShareShared;
2070: partial->Flags = (USHORT)ConfigData->Controller[i].ResourcePortType;
2071: partial->u.Port.Start = RtlLargeIntegerAdd(
2072: ConfigData->Controller[i].OriginalBaseAddress,
2073: RtlConvertUlongToLargeInteger((ULONG)7)
2074: );
2075: partial->u.Port.Length = 1;
2076:
2077: partial++;
2078:
2079: partial->Type = CmResourceTypeDma;
2080: partial->ShareDisposition = CmResourceShareShared;
2081: partial->Flags = 0;
2082: partial->u.Dma.Channel =
2083: ConfigData->Controller[i].OriginalDmaChannel;
2084:
2085: partial++;
2086:
2087: //
2088: // Now fill in the irq stuff.
2089: //
2090:
2091: partial->Type = CmResourceTypeInterrupt;
2092: partial->u.Interrupt.Level =
2093: ConfigData->Controller[i].OriginalIrql;
2094: partial->u.Interrupt.Vector =
2095: ConfigData->Controller[i].OriginalVector;
2096:
2097: // if (nextFrd->InterfaceType == MicroChannel) {
2098: //
2099: // partial->ShareDisposition = CmResourceShareShared;
2100: //
2101: // } else {
2102: //
2103: // partial->ShareDisposition = CmResourceShareDriverExclusive;
2104: //
2105: // }
2106:
2107: partial->ShareDisposition = CmResourceShareShared;
2108:
2109: if (ConfigData->Controller[i].InterruptMode == Latched) {
2110:
2111: partial->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
2112:
2113: } else {
2114:
2115: partial->Flags = CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE;
2116:
2117: }
2118:
2119: partial++;
2120:
2121: nextFrd = (PVOID)partial;
2122:
2123: numberOfFrds--;
2124:
2125: }
2126:
2127: }
2128:
2129: IoReportResourceUsage(
2130: NULL,
2131: DriverObject,
2132: resourceList,
2133: sizeOfResourceList,
2134: NULL,
2135: NULL,
2136: 0,
2137: FALSE,
2138: &ConfigData->Controller[ControllerNumber].OkToUseThisController
2139: );
2140:
2141: //
2142: // The above routine sets the boolean the parameter
2143: // to TRUE if a conflict was detected.
2144: //
2145:
2146: ConfigData->Controller[ControllerNumber].OkToUseThisController =
2147: !ConfigData->Controller[ControllerNumber].OkToUseThisController;
2148:
2149: ExFreePool(resourceList);
2150:
2151: return ConfigData->Controller[ControllerNumber].OkToUseThisController;
2152:
2153: }
2154:
2155: NTSTATUS
2156: FlInitializeController(
2157: IN PCONFIG_DATA ConfigData,
2158: IN UCHAR ControllerNumber,
2159: IN PDRIVER_OBJECT DriverObject
2160: )
2161:
2162: /*++
2163:
2164: Routine Description:
2165:
2166: This routine is called at initialization time by DriverEntry() -
2167: once for each controller that the configuration manager tells it we
2168: have to support.
2169:
2170: When this routine is called, the configuration data has already been
2171: filled in.
2172:
2173: Arguments:
2174:
2175: ConfigData - a pointer to the structure that describes the
2176: controller and the disks attached to it, as given to us by the
2177: configuration manager.
2178:
2179: ControllerNumber - which controller in ConfigData we are
2180: initializing.
2181:
2182: DriverObject - a pointer to the object that represents this device
2183: driver.
2184:
2185: Return Value:
2186:
2187: STATUS_SUCCESS if this controller and at least one of its disks were
2188: initialized; an error otherwise.
2189:
2190: --*/
2191:
2192: {
2193: PCONTROLLER_DATA controllerData;
2194: PVOID threadObject;
2195: CONFIG_CONTROLLER_DATA *tempData;
2196: NTSTATUS ntStatus;
2197: NTSTATUS ntStatus2;
2198: ULONG ioBufferSize;
2199: ULONG maximumDriveTrackSize;
2200: HANDLE threadHandle = 0;
2201: UCHAR driveNumber;
2202: BOOLEAN partlySuccessful;
2203: UCHAR ntNameBuffer[256];
2204: STRING ntNameString;
2205: UNICODE_STRING ntUnicodeString;
2206: OBJECT_ATTRIBUTES objectAttributes;
2207:
2208: FloppyDump(
2209: FLOPSHOW,
2210: ("Floppy: FlInitializeController...\n")
2211: );
2212:
2213: //
2214: // This routine will take attempt to "append" the resources
2215: // used by this controller into the resource map of the
2216: // registry. If there was a conflict with previously "declared"
2217: // data, then this routine will return false, in which case we
2218: // will NOT try to initialize this particular controller.
2219: //
2220:
2221: if (!FlReportResources(
2222: DriverObject,
2223: ConfigData,
2224: ControllerNumber
2225: )) {
2226:
2227: return STATUS_INSUFFICIENT_RESOURCES;
2228:
2229: }
2230:
2231: //
2232: // Allocate and zero-initialize data to describe this controller
2233: //
2234:
2235: controllerData = (PCONTROLLER_DATA) ExAllocatePool(
2236: NonPagedPool,
2237: sizeof( CONTROLLER_DATA ) );
2238:
2239: if ( controllerData == NULL ) {
2240:
2241: return STATUS_INSUFFICIENT_RESOURCES;
2242: }
2243:
2244: RtlZeroMemory( controllerData, sizeof( CONTROLLER_DATA ) );
2245:
2246: (VOID) sprintf(
2247: ntNameBuffer,
2248: "\\Device\\FloppyControllerEvent%d",
2249: ControllerNumber );
2250:
2251: RtlInitString( &ntNameString, ntNameBuffer );
2252:
2253: ntStatus = RtlAnsiStringToUnicodeString(
2254: &ntUnicodeString,
2255: &ntNameString,
2256: TRUE );
2257:
2258: InitializeObjectAttributes(
2259: &objectAttributes,
2260: &ntUnicodeString,
2261: OBJ_PERMANENT | OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
2262: NULL,
2263: NULL );
2264:
2265:
2266: controllerData->ControllerEvent = IoCreateSynchronizationEvent(
2267: &ntUnicodeString,
2268: &controllerData->ControllerEventHandle);
2269:
2270: RtlFreeUnicodeString( &ntUnicodeString );
2271:
2272: if ( !NT_SUCCESS( ntStatus ) ) {
2273: return STATUS_INSUFFICIENT_RESOURCES;
2274: }
2275:
2276: //
2277: // Stick the driver object into it so that we can use it to log
2278: // an error if the controller hangs up.
2279: //
2280:
2281: controllerData->DriverObject = DriverObject;
2282:
2283: //
2284: // Fill in some items that we got from configuration management and
2285: // the HAL.
2286: //
2287:
2288: controllerData->ControllerAddress =
2289: ConfigData->Controller[ControllerNumber].ControllerBaseAddress;
2290: controllerData->AdapterObject =
2291: ConfigData->Controller[ControllerNumber].AdapterObject;
2292: controllerData->NumberOfMapRegisters =
2293: ConfigData->Controller[ControllerNumber].NumberOfMapRegisters;
2294: controllerData->NumberOfDrives =
2295: ConfigData->Controller[ControllerNumber].NumberOfDrives;
2296:
2297: //
2298: // Set the time to wait for an interrupt before timing out to a
2299: // few seconds.
2300: //
2301:
2302: controllerData->InterruptDelay = RtlLargeIntegerNegate(
2303: RtlConvertLongToLargeInteger(
2304: (LONG)(10 * 1000 * 4000)
2305: )
2306: );
2307:
2308: //
2309: // Set the minimum time that we can delay (10ms according to system
2310: // rules). This will be used when we have to delay to, say, wait
2311: // for the FIFO - the FIFO should become ready is well under 10ms.
2312: //
2313:
2314: controllerData->Minimum10msDelay = RtlLargeIntegerNegate(
2315: RtlConvertLongToLargeInteger(
2316: (LONG)(10 * 1000 * 10)
2317: )
2318: );
2319:
2320: //
2321: // Occasionally during stress we've seen the device lock up.
2322: // We create a dpc so that we can log that the device lock up
2323: // occured and that we reset the device.
2324: //
2325:
2326: KeInitializeDpc(
2327: &controllerData->LogErrorDpc,
2328: FlLogErrorDpc,
2329: controllerData
2330: );
2331:
2332: //
2333: // Assume there is a CONFIGURE command until found otherwise.
2334: // Other Booleans were zero-initialized to FALSE.
2335: //
2336:
2337: controllerData->ControllerConfigurable = TRUE;
2338:
2339: //
2340: // Initialize and connect to the interrupt object in the controller
2341: // extension.
2342: //
2343:
2344: controllerData->CurrentInterrupt = TRUE;
2345:
2346: ntStatus = IoConnectInterrupt(
2347: &controllerData->InterruptObject,
2348: FloppyInterruptService,
2349: controllerData,
2350: NULL,
2351: ConfigData->Controller[ControllerNumber].ControllerVector,
2352: ConfigData->Controller[ControllerNumber].ControllerIrql,
2353: ConfigData->Controller[ControllerNumber].ControllerIrql,
2354: ConfigData->Controller[ControllerNumber].InterruptMode,
2355: ConfigData->Controller[ControllerNumber].SharableVector,
2356: ConfigData->Controller[ControllerNumber].ProcessorMask,
2357: ConfigData->Controller[ControllerNumber].SaveFloatState);
2358:
2359: controllerData->CurrentInterrupt = TRUE;
2360:
2361: if ( NT_SUCCESS( ntStatus ) ) {
2362:
2363: //
2364: // Allocate spinlock to protect controller and data
2365: //
2366:
2367: KeInitializeSpinLock( &controllerData->TimerSpinLock );
2368:
2369: //
2370: // Calculate the size of the largest track that we could possibly
2371: // deal with on this controller.
2372: //
2373:
2374: ioBufferSize = 0;
2375: tempData = &ConfigData->Controller[ControllerNumber];
2376:
2377: for ( driveNumber = 0;
2378: driveNumber < tempData->NumberOfDrives;
2379: driveNumber++ ) {
2380:
2381: //
2382: // Get the size out of the BIOS information store in the
2383: // diskette configuration information
2384: //
2385:
2386: maximumDriveTrackSize =
2387: tempData->BiosDriveMediaConstants[driveNumber].BytesPerSector *
2388: tempData->BiosDriveMediaConstants[driveNumber].SectorsPerTrack;
2389:
2390: if ( maximumDriveTrackSize > ioBufferSize ) {
2391:
2392: ioBufferSize = maximumDriveTrackSize;
2393: }
2394: }
2395:
2396: //
2397: // If we don't have enough map registers to handle the largest
2398: // possible track size, allocate a contiguous buffer to hold it.
2399: //
2400:
2401: if ( ( tempData->NumberOfMapRegisters * PAGE_SIZE ) < ioBufferSize ) {
2402:
2403: controllerData->IoBuffer = MmAllocateContiguousMemory(
2404: ioBufferSize,
2405: RtlConvertUlongToLargeInteger (MAXIMUM_DMA_ADDRESS) );
2406:
2407: }
2408:
2409: //
2410: // We need a single page to do FORMATs. If we already allocated a
2411: // buffer, we'll use that. If not, let's allocate a single page.
2412: // Note that we'd have to do this anyway if there's not enough map
2413: // registers.
2414: //
2415:
2416: if ( controllerData->IoBuffer == NULL ) {
2417:
2418: ioBufferSize = PAGE_SIZE;
2419:
2420: controllerData->IoBuffer = ExAllocatePool(
2421: NonPagedPool,
2422: ioBufferSize );
2423: }
2424:
2425: //
2426: // If we can't even get a page to use as a buffer, exit.
2427: //
2428:
2429: if ( controllerData->IoBuffer == NULL ) {
2430:
2431: ntStatus = STATUS_INSUFFICIENT_RESOURCES;
2432:
2433: } else {
2434:
2435: //
2436: // We have a buffer. Get and lock down an MDL for it now.
2437: //
2438:
2439: controllerData->IoBufferMdl = IoAllocateMdl(
2440: controllerData->IoBuffer,
2441: ioBufferSize,
2442: FALSE,
2443: FALSE,
2444: NULL );
2445:
2446: if ( controllerData->IoBufferMdl == NULL ) {
2447:
2448: ntStatus = STATUS_INSUFFICIENT_RESOURCES;
2449:
2450: } else {
2451:
2452: MmProbeAndLockPages(
2453: controllerData->IoBufferMdl,
2454: KernelMode,
2455: IoModifyAccess );
2456:
2457: FloppyDump(
2458: FLOPSHOW,
2459: ("Floppy: Buffer size = %x\n", ioBufferSize)
2460: );
2461:
2462: controllerData->IoBufferSize = ioBufferSize;
2463:
2464: //
2465: // Initialize the interlocked request queue, including a
2466: // counting semaphore to indicate items in the queue
2467: //
2468:
2469: KeInitializeSemaphore(
2470: &controllerData->RequestSemaphore,
2471: 0L,
2472: MAXLONG );
2473:
2474: KeInitializeSpinLock( &controllerData->ListSpinLock );
2475:
2476: InitializeListHead( &controllerData->ListEntry );
2477:
2478: //
2479: // Initialize events to signal interrupts and adapter object
2480: // allocation
2481: //
2482:
2483: KeInitializeEvent(
2484: &controllerData->InterruptEvent,
2485: SynchronizationEvent,
2486: FALSE);
2487:
2488: KeInitializeEvent(
2489: &controllerData->AllocateAdapterChannelEvent,
2490: NotificationEvent,
2491: FALSE );
2492:
2493: //
2494: // Create a thread with entry point FloppyThread()
2495: //
2496:
2497: ntStatus = PsCreateSystemThread(
2498: &threadHandle,
2499: (ACCESS_MASK) 0L,
2500: NULL,
2501: (HANDLE) 0L,
2502: NULL,
2503: FloppyThread,
2504: controllerData );
2505:
2506: if ( !NT_SUCCESS( ntStatus ) ) {
2507:
2508: FloppyDump(
2509: FLOPDBGP,
2510: ("Floppy: error %x creating thread\n",ntStatus)
2511: );
2512:
2513: }
2514:
2515: if ( NT_SUCCESS( ntStatus ) ) {
2516:
2517: //
2518: // Call FlInitializeDrive() for each drive on the
2519: // controller
2520: //
2521:
2522: ntStatus = STATUS_NO_SUCH_DEVICE;
2523: partlySuccessful = FALSE;
2524:
2525: for ( driveNumber = 0;
2526: driveNumber < controllerData->NumberOfDrives;
2527: driveNumber++ ) {
2528:
2529: ntStatus = FlInitializeDrive(
2530: ConfigData,
2531: controllerData,
2532: ControllerNumber,
2533: driveNumber,
2534: driveNumber,
2535: DriverObject );
2536:
2537: if ( NT_SUCCESS( ntStatus ) ) {
2538:
2539: ( *( ConfigData->FloppyCount ) )++;
2540: partlySuccessful = TRUE;
2541: }
2542: }
2543:
2544: if ( partlySuccessful ) {
2545:
2546: ntStatus = STATUS_SUCCESS;
2547: }
2548: }
2549: }
2550: }
2551: }
2552:
2553: //
2554: // If we're exiting with an error, clean up first.
2555: //
2556:
2557: if ( !NT_SUCCESS( ntStatus ) ) {
2558:
2559: FloppyDump(
2560: FLOPDBGP,
2561: ("Floppy: InitializeController failing\n")
2562: );
2563:
2564: //
2565: // If we created the thread, wake it up and tell it to kill itself.
2566: // Wait until it's dead. (Note that since it's a system thread,
2567: // it has to kill itself - we can't do it).
2568: //
2569:
2570: if ( threadHandle != 0 ) {
2571:
2572: controllerData->UnloadingDriver = TRUE;
2573:
2574: ntStatus2 = ObReferenceObjectByHandle(
2575: threadHandle,
2576: THREAD_ALL_ACCESS,
2577: NULL,
2578: KernelMode,
2579: (PVOID *) &threadObject,
2580: NULL );
2581:
2582: KeReleaseSemaphore(
2583: &controllerData->RequestSemaphore,
2584: (KPRIORITY) 0,
2585: 1,
2586: FALSE );
2587:
2588: if ( NT_SUCCESS( ntStatus2 ) ) {
2589:
2590: //
2591: // The thread object will be signalled when it dies.
2592: //
2593:
2594: ntStatus2 = KeWaitForSingleObject(
2595: threadObject,
2596: Suspended,
2597: KernelMode,
2598: FALSE,
2599: NULL );
2600:
2601: ASSERT( ntStatus2 == STATUS_SUCCESS );
2602:
2603: ObDereferenceObject( threadObject );
2604:
2605: } else {
2606:
2607: //
2608: // We can't get the thread object for some reason; just
2609: // block for a while to give the thread a chance to run
2610: // and die.
2611: //
2612:
2613: FloppyDump(
2614: FLOPDBGP,
2615: ("Floppy: couldn't get thread object\n")
2616: );
2617:
2618: KeDelayExecutionThread(
2619: KernelMode,
2620: FALSE,
2621: &controllerData->InterruptDelay );
2622: }
2623: }
2624:
2625: if ( controllerData->IoBufferMdl != NULL ) {
2626:
2627: MmUnlockPages( controllerData->IoBufferMdl );
2628: IoFreeMdl( controllerData->IoBufferMdl );
2629: }
2630:
2631: if ( controllerData->IoBuffer != NULL ) {
2632:
2633: if ( controllerData->IoBufferSize > PAGE_SIZE ) {
2634:
2635: MmFreeContiguousMemory( controllerData->IoBuffer );
2636:
2637: } else {
2638:
2639: ExFreePool( controllerData->IoBuffer );
2640: }
2641: }
2642:
2643: if ( controllerData->InterruptObject != NULL ) {
2644:
2645: IoDisconnectInterrupt( controllerData->InterruptObject );
2646: }
2647:
2648: ExFreePool( controllerData );
2649:
2650: //
2651: // Support for the ghost drive is being removed. If it
2652: // is needed later, then we can just "un" ifdef this
2653: // code.
2654: //
2655:
2656: #ifdef FLOPPY_ARTIFICIAL
2657:
2658: } else {
2659:
2660: //
2661: // Controller and drive initialization were successful. If
2662: // there's only 1 drive, set up an artificial second drive to
2663: // point to the same thing.
2664: //
2665:
2666: if ( ( ConfigData->NumberOfControllers == 1 ) &&
2667: ( controllerData->NumberOfDrives == 1 ) ) {
2668:
2669: //
2670: // Discard status, since we want to return success even
2671: // if this artificial creation fails.
2672: //
2673:
2674: ntStatus2 = FlInitializeDrive(
2675: ConfigData,
2676: controllerData,
2677: ControllerNumber,
2678: 1,
2679: 0,
2680: DriverObject );
2681:
2682: if ( NT_SUCCESS( ntStatus2 ) ) {
2683:
2684: controllerData->CreatedArtificialDrive = TRUE;
2685: }
2686: }
2687: #endif
2688: }
2689:
2690: return ntStatus;
2691: }
2692:
2693: NTSTATUS
2694: FlInitializeControllerHardware(
2695: IN PCONTROLLER_DATA ControllerData,
2696: IN PDEVICE_OBJECT DeviceObject
2697: )
2698:
2699: /*++
2700:
2701: Routine Description:
2702:
2703: This routine is called at initialization time by FlInitializeDrive()
2704: - once for each controller that we have to support. It is also
2705: called by FlFinishOperation() when an operation appears to have
2706: failed due to a hardware problem.
2707:
2708: When this routine is called, the controller data structures have all
2709: been allocated.
2710:
2711: Arguments:
2712:
2713: ControllerData - the completed data structure associated with the
2714: controller hardware being initialized.
2715:
2716: DeviceObject - a pointer to a device object; this routine will cause
2717: an interrupt, and the ISR requires CurrentDeviceObject to be filled
2718: in.
2719:
2720: Return Value:
2721:
2722: STATUS_SUCCESS if this controller appears to have been reset properly,
2723: error otherwise.
2724:
2725: --*/
2726:
2727: {
2728: NTSTATUS ntStatus;
2729: UCHAR statusRegister0;
2730: UCHAR cylinder;
2731: UCHAR driveNumber;
2732:
2733: FloppyDump(
2734: FLOPSHOW,
2735: ("Floppy: FlInitializeControllerHardware...\n")
2736: );
2737:
2738: //
2739: // Reset the controller. This will cause an interrupt. Reset
2740: // CurrentDeviceObject until after the 10ms wait, in case any
2741: // stray interrupts come in.
2742: //
2743:
2744: ControllerData->DriveControlImage |= DRVCTL_ENABLE_DMA_AND_INTERRUPTS;
2745: ControllerData->DriveControlImage &= ~( DRVCTL_ENABLE_CONTROLLER );
2746:
2747: WRITE_CONTROLLER(
2748: &ControllerData->ControllerAddress->DriveControl,
2749: ControllerData->DriveControlImage );
2750:
2751: KeStallExecutionProcessor( 10 );
2752:
2753: ControllerData->CurrentDeviceObject = DeviceObject;
2754: ControllerData->CommandHasResultPhase = FALSE;
2755: KeResetEvent( &ControllerData->InterruptEvent );
2756:
2757: ControllerData->DriveControlImage |= DRVCTL_ENABLE_CONTROLLER;
2758:
2759: WRITE_CONTROLLER(
2760: &ControllerData->ControllerAddress->DriveControl,
2761: ControllerData->DriveControlImage );
2762:
2763: //
2764: // Wait for an interrupt. Note that STATUS_TIMEOUT and STATUS_SUCCESS
2765: // are the only possible return codes, since we aren't alertable and
2766: // won't get APCs.
2767: //
2768:
2769: ntStatus = KeWaitForSingleObject(
2770: &ControllerData->InterruptEvent,
2771: Executive,
2772: KernelMode,
2773: FALSE,
2774: &ControllerData->InterruptDelay );
2775:
2776: if ( ntStatus == STATUS_TIMEOUT ) {
2777:
2778: //
2779: // Change info to an error.
2780: //
2781:
2782: ntStatus = STATUS_IO_TIMEOUT;
2783:
2784: ControllerData->HardwareFailed = TRUE;
2785: }
2786:
2787: #ifdef KEEP_COUNTERS
2788: FloppyThreadTime = KeQueryPerformanceCounter((PVOID)NULL);
2789: FloppyThreadDelay = RtlLargeIntegerAdd(FloppyThreadDelay,
2790: RtlLargeIntegerSubtract(FloppyDPCTime,
2791: FloppyThreadTime));
2792: FloppyFromIntrDelay = RtlLargeIntegerAdd(FloppyFromIntrDelay,
2793: RtlLargeIntegerSubtract(FloppyIntrTime,
2794: FloppyThreadTime));
2795: FloppyThreadWake++;
2796: #endif
2797:
2798: if ( !NT_SUCCESS( ntStatus ) ) {
2799:
2800: FloppyDump(
2801: FLOPDBGP,
2802: ("Floppy: controller didn't interrupt after reset\n")
2803: );
2804:
2805: return ntStatus;
2806: }
2807:
2808: //
2809: // Sense interrupt status for all drives.
2810: //
2811:
2812: for ( driveNumber = 0;
2813: ( driveNumber < ControllerData->NumberOfDrives ) &&
2814: ( NT_SUCCESS( ntStatus ) );
2815: driveNumber++ ) {
2816:
2817: if ( driveNumber != 0 ) {
2818:
2819: //
2820: // Note that the ISR issued first SENSE INTERRUPT for us.
2821: //
2822:
2823: ntStatus = FlSendByte( COMMND_SENSE_INTERRUPT, ControllerData );
2824: }
2825:
2826: if ( NT_SUCCESS( ntStatus ) ) {
2827:
2828: ntStatus = FlGetByte( &statusRegister0, ControllerData );
2829:
2830: if ( NT_SUCCESS( ntStatus ) ) {
2831:
2832: ntStatus = FlGetByte( &cylinder, ControllerData );
2833: }
2834: }
2835: }
2836:
2837: //
2838: // Set PERPENDICULAR MODE for all drives that are perpendicular.
2839: //
2840:
2841: if ( ControllerData->PerpendicularDrives != 0 ) {
2842: ntStatus = FlSendByte( COMMND_PERPENDICULAR_MODE, ControllerData );
2843:
2844: if ( NT_SUCCESS( ntStatus ) ) {
2845: ntStatus = FlSendByte( COMMND_PERPENDICULAR_MODE_OW |
2846: (ControllerData->PerpendicularDrives << 2),
2847: ControllerData );
2848: }
2849: }
2850:
2851: return ntStatus;
2852: }
2853:
2854: NTSTATUS
2855: FlInitializeDrive(
2856: IN PCONFIG_DATA ConfigData,
2857: IN PCONTROLLER_DATA ControllerData,
2858: IN UCHAR ControllerNum,
2859: IN UCHAR DisketteNum,
2860: IN UCHAR DisketteUnit,
2861: IN PDRIVER_OBJECT DriverObject
2862: )
2863:
2864: /*++
2865:
2866: Routine Description:
2867:
2868: This routine is called at initialization time by
2869: FlInitializeController(), once for each disk that we are supporting
2870: on the controller.
2871:
2872: Arguments:
2873:
2874: ConfigData - a pointer to the structure that describes the
2875: controller and the disks attached to it, as given to us by the
2876: configuration manager.
2877:
2878: ControllerData - a pointer to our data area for this controller.
2879:
2880: ControllerNum - which controller in ConfigData we're working on.
2881:
2882: DisketteNum - which logical disk on the current controller we're
2883: working on.
2884:
2885: DisketteUnit - which physical disk on the current controller we're
2886: working on. Only different from DisketteNum when we're creating a
2887: secondary device object for a previously initialized drive.
2888:
2889: DriverObject - a pointer to the object that represents this device
2890: driver.
2891:
2892: Return Value:
2893:
2894: STATUS_SUCCESS if this disk is initialized; an error otherwise.
2895:
2896: --*/
2897:
2898: {
2899: UCHAR ntNameBuffer[256];
2900: UCHAR arcNameBuffer[256];
2901: STRING ntNameString;
2902: STRING arcNameString;
2903: UNICODE_STRING ntUnicodeString;
2904: UNICODE_STRING arcUnicodeString;
2905: NTSTATUS ntStatus;
2906: PDEVICE_OBJECT deviceObject = NULL;
2907: PDISKETTE_EXTENSION disketteExtension;
2908:
2909: FloppyDump(
2910: FLOPSHOW,
2911: ("Floppy: FlInitializeDrive...\n")
2912: );
2913:
2914: sprintf(
2915: ntNameBuffer,
2916: "\\Device\\Floppy%d",
2917: *( ConfigData->FloppyCount ) );
2918:
2919: RtlInitString( &ntNameString, ntNameBuffer );
2920:
2921: ntStatus = RtlAnsiStringToUnicodeString(
2922: &ntUnicodeString,
2923: &ntNameString,
2924: TRUE );
2925:
2926: if ( NT_SUCCESS( ntStatus ) ) {
2927:
2928: //
2929: // Create a device object for this floppy drive.
2930: //
2931:
2932: ntStatus = IoCreateDevice(
2933: DriverObject,
2934: sizeof( DISKETTE_EXTENSION ),
2935: &ntUnicodeString,
2936: FILE_DEVICE_DISK,
2937: FILE_REMOVABLE_MEDIA | FILE_FLOPPY_DISKETTE,
2938: FALSE,
2939: &deviceObject );
2940:
2941: if ( NT_SUCCESS( ntStatus ) ) {
2942:
2943: //
2944: // Create a symbolic link from the disk name to the corresponding
2945: // ARC name, to be used if we're booting off the disk. This will
2946: // if it's not system initialization time; that's fine. The ARC
2947: // name looks something like \ArcName\multi(0)disk(0)rdisk(0).
2948: //
2949:
2950: sprintf(
2951: arcNameBuffer,
2952: "%s(%d)disk(%d)fdisk(%d)",
2953: "\\ArcName\\multi",
2954: ConfigData->Controller[ControllerNum].BusNumber,
2955: ConfigData->Controller[ControllerNum].ActualControllerNumber,
2956: DisketteNum );
2957:
2958: RtlInitString( &arcNameString, arcNameBuffer );
2959:
2960: ntStatus = RtlAnsiStringToUnicodeString(
2961: &arcUnicodeString,
2962: &arcNameString,
2963: TRUE );
2964:
2965: if ( !NT_SUCCESS( ntStatus ) ) {
2966:
2967: RtlFreeUnicodeString( &ntUnicodeString );
2968:
2969: } else {
2970:
2971: IoAssignArcName( &arcUnicodeString, &ntUnicodeString );
2972: RtlFreeUnicodeString( &ntUnicodeString );
2973: RtlFreeUnicodeString( &arcUnicodeString );
2974:
2975: //
2976: // Initialize the DPC structure in the device object, so that
2977: // the ISR can queue DPCs.
2978: //
2979:
2980: IoInitializeDpcRequest( deviceObject, FloppyDeferredProcedure );
2981:
2982: deviceObject->Flags |= DO_DIRECT_IO;
2983:
2984: if ( deviceObject->AlignmentRequirement < FILE_WORD_ALIGNMENT ) {
2985:
2986: deviceObject->AlignmentRequirement = FILE_WORD_ALIGNMENT;
2987: }
2988:
2989: //
2990: // Copy the drive type from the configuration info; note that
2991: // the media type has not been determined.
2992: //
2993:
2994: disketteExtension = deviceObject->DeviceExtension;
2995:
2996: //
2997: // In the event that the system only has one drive, we
2998: // want this variable to initially point to the extension
2999: // of the *first* device object that describes it, so the
3000: // user's initial access of the drive doesn't result in
3001: // a prompt to insert media.
3002: //
3003:
3004: if ( ( DisketteNum == 0 ) && ( DisketteUnit == 0 ) ) {
3005:
3006: ControllerData->LastDisketteExtension = disketteExtension;
3007: }
3008:
3009: disketteExtension->ControllerData = ControllerData;
3010: disketteExtension->DeviceObject = deviceObject;
3011: disketteExtension->DeviceUnit = DisketteUnit;
3012:
3013: disketteExtension->DriveOnValue = (UCHAR)( DisketteUnit |
3014: ( DRVCTL_ENABLE_CONTROLLER +
3015: DRVCTL_ENABLE_DMA_AND_INTERRUPTS ) |
3016: ( DRVCTL_DRIVE_0 << DisketteUnit ) );
3017:
3018: disketteExtension->DriveType = ConfigData->
3019: Controller[ControllerNum].DriveType[DisketteUnit];
3020:
3021: disketteExtension->MediaType = Undetermined;
3022:
3023: disketteExtension->BiosDriveMediaConstants = ConfigData->
3024: Controller[ControllerNum].BiosDriveMediaConstants[DisketteUnit];
3025:
3026: if ( disketteExtension->DriveType == DRIVE_TYPE_2880 ) {
3027: ControllerData->PerpendicularDrives |= 1 << DisketteUnit;
3028: }
3029:
3030: //
3031: // If this is the first drive, start the motor timer (this
3032: // would best be done in FlInitializeController(), but we
3033: // must have a device object to attach to it.)
3034: //
3035:
3036: if ( DisketteNum == 0 ) {
3037:
3038: ControllerData->MotorTimer = TIMER_CANCEL;
3039:
3040: IoInitializeTimer(
3041: deviceObject,
3042: FloppyMotorOffDpc,
3043: ControllerData );
3044:
3045: IoStartTimer( deviceObject );
3046: }
3047:
3048: //
3049: // FlInitializeControllerHardware() should logically be called
3050: // from FlInitializeController(). But the hardware can't be
3051: // initialized until a device object exists, since the ISR has
3052: // to queue a DPC. So we do it here, where we get a chance to
3053: // clean up easily if FlInitializeControllerHardware() fails.
3054: //
3055: // The controller is normally only reset once, when the first
3056: // diskette is initialized. But we'll try again on subsequent
3057: // diskettes if it failed on the first one.
3058: //
3059:
3060: if ( ( DisketteNum == 0 ) ||
3061: ( disketteExtension->DriveType == DRIVE_TYPE_2880 ) ||
3062: ( ControllerData->HardwareFailed ) ) {
3063:
3064: ControllerData->CurrentInterrupt = TRUE;
3065:
3066: ntStatus = FlInitializeControllerHardware(
3067: ControllerData,
3068: deviceObject );
3069:
3070: ControllerData->CurrentInterrupt = FALSE;
3071:
3072: if ( NT_SUCCESS( ntStatus ) ) {
3073:
3074: FloppyDump(
3075: FLOPSHOW,
3076: ("Floppy: DriveType = %x\n",
3077: disketteExtension->DriveType)
3078: );
3079:
3080: ControllerData->HardwareFailed = FALSE;
3081:
3082: } else {
3083:
3084: ControllerData->HardwareFailed = TRUE;
3085: }
3086: }
3087: }
3088: }
3089: }
3090:
3091: //
3092: // If we're failing, clean up - stop the timer (it doesn't hurt to
3093: // stop it even if it wasn't started) and delete the device object.
3094: //
3095:
3096: if ( !NT_SUCCESS( ntStatus ) ) {
3097:
3098: FloppyDump(
3099: FLOPDBGP,
3100: ("Floppy: InitiaiizeDrive failing\n")
3101: );
3102:
3103: if ( deviceObject != NULL ) {
3104:
3105: if ( DisketteNum == 0 ) {
3106:
3107: IoStopTimer( deviceObject );
3108: }
3109:
3110: IoDeleteDevice( deviceObject );
3111: }
3112: }
3113:
3114: return ntStatus;
3115: }
3116:
3117: NTSTATUS
3118: FloppyDispatchCreateClose(
3119: IN PDEVICE_OBJECT DeviceObject,
3120: IN PIRP Irp
3121: )
3122:
3123: /*++
3124:
3125: Routine Description:
3126:
3127: This routine is called only rarely by the I/O system; it's mainly
3128: for layered drivers to call. All it does is complete the IRP
3129: successfully.
3130:
3131: Arguments:
3132:
3133: DeviceObject - a pointer to the object that represents the device
3134: that I/O is to be done on.
3135:
3136: Irp - a pointer to the I/O Request Packet for this request.
3137:
3138: Return Value:
3139:
3140: Always returns STATUS_SUCCESS, since this is a null operation.
3141:
3142: --*/
3143:
3144: {
3145: UNREFERENCED_PARAMETER( DeviceObject );
3146:
3147: FloppyDump(
3148: FLOPSHOW,
3149: ("Floppy: DispatchCreateClose...\n")
3150: );
3151:
3152: //
3153: // Null operation. Do not give an I/O boost since
3154: // no I/O was actually done. IoStatus.Information should be
3155: // FILE_OPENED for an open; it's undefined for a close.
3156: //
3157:
3158: Irp->IoStatus.Status = STATUS_SUCCESS;
3159: Irp->IoStatus.Information = FILE_OPENED;
3160:
3161: IoCompleteRequest( Irp, IO_NO_INCREMENT );
3162:
3163: return STATUS_SUCCESS;
3164: }
3165:
3166: NTSTATUS
3167: FloppyDispatchDeviceControl(
3168: IN PDEVICE_OBJECT DeviceObject,
3169: IN PIRP Irp
3170: )
3171:
3172: /*++
3173:
3174: Routine Description:
3175:
3176: This routine is called by the I/O system to perform a device I/O
3177: control function.
3178:
3179: Arguments:
3180:
3181: DeviceObject - a pointer to the object that represents the device
3182: that I/O is to be done on.
3183:
3184: Irp - a pointer to the I/O Request Packet for this request.
3185:
3186: Return Value:
3187:
3188: STATUS_SUCCESS or STATUS_PENDING if recognized I/O control code,
3189: STATUS_INVALID_DEVICE_REQUEST otherwise.
3190:
3191: --*/
3192:
3193: {
3194: PIO_STACK_LOCATION irpSp;
3195: PDISKETTE_EXTENSION disketteExtension;
3196: PDISK_GEOMETRY outputBuffer;
3197: NTSTATUS ntStatus;
3198: ULONG outputBufferLength;
3199: UCHAR i;
3200: DRIVE_MEDIA_TYPE lowestDriveMediaType;
3201: DRIVE_MEDIA_TYPE highestDriveMediaType;
3202:
3203: FloppyDump(
3204: FLOPSHOW,
3205: ("Floppy: DispatchDeviceControl...\n")
3206: );
3207:
3208: disketteExtension = DeviceObject->DeviceExtension;
3209: irpSp = IoGetCurrentIrpStackLocation( Irp );
3210:
3211: switch( irpSp->Parameters.DeviceIoControl.IoControlCode ) {
3212:
3213: case IOCTL_DISK_FORMAT_TRACKS:
3214:
3215: //
3216: // Make sure that we got all the necessary format parameters.
3217: //
3218:
3219: if ( irpSp->Parameters.DeviceIoControl.InputBufferLength <
3220: sizeof( FORMAT_PARAMETERS ) ) {
3221:
3222: FloppyDump(
3223: FLOPDBGP,
3224: ("Floppy: invalid FORMAT buffer length\n")
3225: );
3226:
3227: ntStatus = STATUS_INVALID_PARAMETER;
3228: break;
3229: }
3230:
3231: //
3232: // Make sure the parameters we got are reasonable.
3233: //
3234:
3235: if ( !FlCheckFormatParameters(
3236: disketteExtension,
3237: (PFORMAT_PARAMETERS) Irp->AssociatedIrp.SystemBuffer ) ) {
3238:
3239: FloppyDump(
3240: FLOPDBGP,
3241: ("Floppy: invalid FORMAT parameters\n")
3242: );
3243:
3244: ntStatus = STATUS_INVALID_PARAMETER;
3245: break;
3246: }
3247:
3248: //
3249: // Fall through to queue the request.
3250: //
3251:
3252: case IOCTL_DISK_CHECK_VERIFY:
3253: case IOCTL_DISK_GET_DRIVE_GEOMETRY:
3254:
3255: //
3256: // The thread must know which diskette to operate on, but the
3257: // request list only passes the IRP. So we'll stick a pointer
3258: // to the diskette extension in Type3InputBuffer, which is
3259: // a field that isn't used for floppy ioctls.
3260: //
3261:
3262: //
3263: // Add the request to the queue, and wake up the thread to
3264: // process it.
3265: //
3266:
3267: IoMarkIrpPending( Irp );
3268:
3269: irpSp->Parameters.DeviceIoControl.Type3InputBuffer = (PVOID)
3270: disketteExtension;
3271:
3272: FloppyDump(
3273: FLOPIRPPATH,
3274: ("Floppy: Enqueing up IRP: %x\n",Irp)
3275: );
3276: ExInterlockedInsertTailList(
3277: &disketteExtension->ControllerData->ListEntry,
3278: &Irp->Tail.Overlay.ListEntry,
3279: &disketteExtension->ControllerData->ListSpinLock );
3280:
3281: KeReleaseSemaphore(
3282: &disketteExtension->ControllerData->RequestSemaphore,
3283: (KPRIORITY) 0,
3284: 1,
3285: FALSE );
3286:
3287: ntStatus = STATUS_PENDING;
3288: break;
3289:
3290:
3291: case IOCTL_DISK_GET_MEDIA_TYPES: {
3292:
3293: FloppyDump(
3294: FLOPSHOW,
3295: ("Floppy: IOCTL_DISK_GET_MEDIA_TYPES called\n")
3296: );
3297:
3298: lowestDriveMediaType = DriveMediaLimits[
3299: disketteExtension->DriveType].LowestDriveMediaType;
3300: highestDriveMediaType = DriveMediaLimits[
3301: disketteExtension->DriveType].HighestDriveMediaType;
3302:
3303: outputBufferLength =
3304: irpSp->Parameters.DeviceIoControl.OutputBufferLength;
3305:
3306: //
3307: // Make sure that the input buffer has enough room to return
3308: // at least one descriptions of a supported media type.
3309: //
3310:
3311: if ( outputBufferLength < ( sizeof( DISK_GEOMETRY ) ) ) {
3312:
3313: FloppyDump(
3314: FLOPDBGP,
3315: ("Floppy: invalid GET_MEDIA_TYPES buffer size\n")
3316: );
3317:
3318: ntStatus = STATUS_BUFFER_TOO_SMALL;
3319: break;
3320: }
3321:
3322: //
3323: // Assume success, although we might modify it to a buffer
3324: // overflow warning below (if the buffer isn't big enough
3325: // to hold ALL of the media descriptions).
3326: //
3327:
3328: ntStatus = STATUS_SUCCESS;
3329:
3330: if ( outputBufferLength < ( sizeof( DISK_GEOMETRY ) *
3331: ( highestDriveMediaType - lowestDriveMediaType + 1 ) ) ) {
3332:
3333: //
3334: // The buffer is too small for all of the descriptions;
3335: // calculate what CAN fit in the buffer.
3336: //
3337:
3338: FloppyDump(
3339: FLOPDBGP,
3340: ("Floppy: GET_MEDIA_TYPES buffer size too small\n")
3341: );
3342:
3343: ntStatus = STATUS_BUFFER_OVERFLOW;
3344:
3345: highestDriveMediaType = (DRIVE_MEDIA_TYPE)( ( lowestDriveMediaType - 1 ) +
3346: ( outputBufferLength /
3347: sizeof( DISK_GEOMETRY ) ) );
3348: }
3349:
3350: outputBuffer = (PDISK_GEOMETRY) Irp->AssociatedIrp.SystemBuffer;
3351:
3352: for (
3353: i = (UCHAR)lowestDriveMediaType;
3354: i <= (UCHAR)highestDriveMediaType;
3355: i++ ) {
3356:
3357: outputBuffer->MediaType = DriveMediaConstants[i].MediaType;
3358: outputBuffer->Cylinders.LowPart =
3359: DriveMediaConstants[i].MaximumTrack + 1;
3360: outputBuffer->Cylinders.HighPart = 0;
3361: outputBuffer->TracksPerCylinder =
3362: DriveMediaConstants[i].NumberOfHeads;
3363: outputBuffer->SectorsPerTrack =
3364: DriveMediaConstants[i].SectorsPerTrack;
3365: outputBuffer->BytesPerSector =
3366: DriveMediaConstants[i].BytesPerSector;
3367: FloppyDump(
3368: FLOPSHOW,
3369: ("Floppy: media types supported [%d]\n"
3370: "------- Cylinders low: 0x%x\n"
3371: "------- Cylinders high: 0x%x\n"
3372: "------- Track/Cyl: 0x%x\n"
3373: "------- Sectors/Track: 0x%x\n"
3374: "------- Bytes/Sector: 0x%x\n"
3375: "------- Media Type: %d\n",
3376: i,
3377: outputBuffer->Cylinders.LowPart,
3378: outputBuffer->Cylinders.HighPart,
3379: outputBuffer->TracksPerCylinder,
3380: outputBuffer->SectorsPerTrack,
3381: outputBuffer->BytesPerSector,
3382: outputBuffer->MediaType)
3383: );
3384: outputBuffer++;
3385:
3386: Irp->IoStatus.Information += sizeof( DISK_GEOMETRY );
3387: }
3388:
3389: break;
3390: }
3391:
3392: default: {
3393:
3394: FloppyDump(
3395: FLOPDBGP,
3396: ("Floppy: invalid device request %x\n",
3397: irpSp->Parameters.DeviceIoControl.IoControlCode)
3398: );
3399:
3400: ntStatus = STATUS_INVALID_DEVICE_REQUEST;
3401: break;
3402: }
3403: }
3404:
3405: if ( ntStatus != STATUS_PENDING ) {
3406:
3407: Irp->IoStatus.Status = ntStatus;
3408: if (!NT_SUCCESS( ntStatus ) &&
3409: IoIsErrorUserInduced( ntStatus )) {
3410:
3411: IoSetHardErrorOrVerifyDevice( Irp, DeviceObject );
3412:
3413: }
3414: IoCompleteRequest( Irp, IO_NO_INCREMENT );
3415: }
3416:
3417: return ntStatus;
3418: }
3419:
3420: NTSTATUS
3421: FloppyDispatchReadWrite(
3422: IN PDEVICE_OBJECT DeviceObject,
3423: IN PIRP Irp
3424: )
3425:
3426: /*++
3427:
3428: Routine Description:
3429:
3430: This routine is called by the I/O system to read or write to a
3431: device that we control.
3432:
3433: Arguments:
3434:
3435: DeviceObject - a pointer to the object that represents the device
3436: that I/O is to be done on.
3437:
3438: Irp - a pointer to the I/O Request Packet for this request.
3439:
3440: Return Value:
3441:
3442: STATUS_INVALID_PARAMETER if parameters are invalid,
3443: STATUS_PENDING otherwise.
3444:
3445: --*/
3446:
3447: {
3448: PIO_STACK_LOCATION irpSp;
3449: NTSTATUS ntStatus;
3450: PDISKETTE_EXTENSION disketteExtension;
3451:
3452: FloppyDump(
3453: FLOPSHOW,
3454: ("Floppy: FloppyDispatchReadWrite...\n")
3455: );
3456:
3457: disketteExtension = DeviceObject->DeviceExtension;
3458:
3459: irpSp = IoGetCurrentIrpStackLocation( Irp );
3460:
3461: if ( ( disketteExtension->MediaType > Unknown ) &&
3462: ( ( ( irpSp->Parameters.Read.ByteOffset ).LowPart +
3463: irpSp->Parameters.Read.Length > disketteExtension->ByteCapacity ) ||
3464: ( ( irpSp->Parameters.Read.Length &
3465: ( disketteExtension->BytesPerSector - 1 ) ) != 0 ) ) ) {
3466:
3467: FloppyDump(
3468: FLOPDBGP,
3469: ("Floppy: Invalid Parameter, rejecting request\n")
3470: );
3471:
3472: FloppyDump(
3473: FLOPWARN,
3474: ("Floppy: Starting offset = %lx\n"
3475: "------ I/O Length = %lx\n"
3476: "------ ByteCapacity = %lx\n"
3477: "------ BytesPerSector = %lx\n",
3478: irpSp->Parameters.Read.ByteOffset.LowPart,
3479: irpSp->Parameters.Read.Length,
3480: disketteExtension->ByteCapacity,
3481: disketteExtension->BytesPerSector)
3482: );
3483:
3484: ntStatus = STATUS_INVALID_PARAMETER;
3485: Irp->IoStatus.Status = ntStatus;
3486: IoCompleteRequest(
3487: Irp,
3488: 0
3489: );
3490:
3491: } else {
3492:
3493: IoMarkIrpPending( Irp );
3494:
3495: //
3496: // We need to pass the disketteExtension somewhere in the irp.
3497: // The "Key" field in our stack location should be unused.
3498: //
3499:
3500: irpSp->Parameters.Read.Key = (ULONG) disketteExtension;
3501:
3502: FloppyDump(
3503: FLOPIRPPATH,
3504: ("Floppy: Enqueing up IRP: %x\n",Irp)
3505: );
3506: ExInterlockedInsertTailList(
3507: &disketteExtension->ControllerData->ListEntry,
3508: &Irp->Tail.Overlay.ListEntry,
3509: &disketteExtension->ControllerData->ListSpinLock );
3510:
3511: KeReleaseSemaphore(
3512: &disketteExtension->ControllerData->RequestSemaphore,
3513: (KPRIORITY) 0,
3514: 1,
3515: FALSE );
3516:
3517: ntStatus = STATUS_PENDING;
3518: }
3519:
3520: return ntStatus;
3521: }
3522:
3523: BOOLEAN
3524: FloppyInterruptService(
3525: IN PKINTERRUPT Interrupt,
3526: IN PVOID Context
3527: )
3528:
3529: /*++
3530:
3531: Routine Description:
3532:
3533: This routine is called at DIRQL by the system when the controller
3534: interrupts.
3535:
3536: Arguments:
3537:
3538: Interrupt - a pointer to the interrupt object.
3539:
3540: Context - a pointer to our controller data area for the controller
3541: that interrupted. (This was set up by the call to
3542: IoConnectInterrupt).
3543:
3544: Return Value:
3545:
3546: Normally returns TRUE, but will return FALSE if this interrupt was
3547: not expected.
3548:
3549: --*/
3550:
3551: {
3552: PCONTROLLER_DATA controllerData;
3553: PDEVICE_OBJECT currentDeviceObject;
3554: ULONG i;
3555: UCHAR statusByte;
3556: BOOLEAN controllerStateError = FALSE;
3557:
3558: UNREFERENCED_PARAMETER( Interrupt );
3559:
3560: #ifdef KEEP_COUNTERS
3561: FloppyIntrTime = KeQueryPerformanceCounter((PVOID)NULL);
3562: FloppyInterrupts++;
3563: #endif
3564:
3565: FloppyDump(
3566: FLOPSHOW,
3567: ("Floppy: FloppyInterruptService...\n")
3568: );
3569:
3570: KeStallExecutionProcessor(10);
3571:
3572: controllerData = (PCONTROLLER_DATA) Context;
3573:
3574: //
3575: // CurrentDeviceObject is set to the device object that is
3576: // expecting an interrupt.
3577: //
3578:
3579: currentDeviceObject = controllerData->CurrentDeviceObject;
3580: controllerData->CurrentDeviceObject = NULL;
3581:
3582: if (currentDeviceObject == NULL &&
3583: !controllerData->CurrentInterrupt) {
3584:
3585: return FALSE;
3586:
3587: } else {
3588:
3589: if ( controllerData->CommandHasResultPhase ) {
3590:
3591: //
3592: // Result phase of previous command. (Note that we can't trust
3593: // the CMD_BUSY bit in the status register to tell us whether
3594: // there's result bytes or not; it's sometimes wrong).
3595: // By reading the first result byte, we reset the interrupt.
3596: // The other result bytes will be read by a thread.
3597: // Note that we want to do this even if the interrupt is
3598: // unexpected, to make sure the interrupt is dismissed.
3599: //
3600:
3601: if ( ( READ_CONTROLLER( &controllerData->ControllerAddress->Status )
3602: & STATUS_IO_READY_MASK ) == STATUS_READ_READY ) {
3603:
3604: controllerData->FifoBuffer[0] =
3605: READ_CONTROLLER( &controllerData->ControllerAddress->Fifo );
3606:
3607: } else {
3608:
3609: //
3610: // Should never get here. If we do, DON'T wake up the thread;
3611: // let it time out and reset the controller, or let another
3612: // interrupt handle this.
3613: //
3614:
3615: FloppyDump(
3616: FLOPDBGP,
3617: ("Floppy: controller not ready to be read in ISR\n")
3618: );
3619:
3620: controllerStateError = TRUE;
3621: }
3622:
3623: } else {
3624:
3625: //
3626: // Previous command doesn't have a result phase. To read how it
3627: // completed, issue a sense interrupt command. Don't read
3628: // the result bytes from the sense interrupt; that is the
3629: // responsibility of the calling thread.
3630: // Note that we want to do this even if the interrupt is
3631: // unexpected, to make sure the interrupt is dismissed.
3632: //
3633:
3634: i = 0;
3635:
3636: do {
3637:
3638: KeStallExecutionProcessor( 1 );
3639: statusByte = READ_CONTROLLER(
3640: &controllerData->ControllerAddress->Status );
3641: i++;
3642:
3643: } while ( ( i < FIFO_ISR_TIGHTLOOP_RETRY_COUNT ) &&
3644: ( ( statusByte & STATUS_CONTROLLER_BUSY ) ||
3645: ( ( statusByte & STATUS_IO_READY_MASK ) != STATUS_WRITE_READY ) ) );
3646:
3647: if ( !( statusByte & STATUS_CONTROLLER_BUSY ) &&
3648: ( ( statusByte & STATUS_IO_READY_MASK ) == STATUS_WRITE_READY ) ) {
3649:
3650: WRITE_CONTROLLER(
3651: &controllerData->ControllerAddress->Fifo,
3652: COMMND_SENSE_INTERRUPT );
3653:
3654: //
3655: // Wait for the controller to ACK the SenseInterrupt command, by
3656: // showing busy. On very fast machines we can end up running
3657: // driver's system-thread before the controller has had time to
3658: // set the busy bit.
3659: //
3660:
3661: for (i = ISR_SENSE_RETRY_COUNT; i; i--) {
3662: statusByte = READ_CONTROLLER(
3663: &controllerData->ControllerAddress->Status );
3664:
3665: if (statusByte & STATUS_CONTROLLER_BUSY)
3666: break;
3667:
3668: KeStallExecutionProcessor( 1 );
3669: }
3670:
3671: if ( currentDeviceObject == NULL ) {
3672:
3673: //
3674: // This is an unexpected interrupt, so nobody's going to
3675: // read the result bytes. Read them now.
3676: //
3677:
3678: READ_CONTROLLER( &controllerData->ControllerAddress->Fifo );
3679: READ_CONTROLLER( &controllerData->ControllerAddress->Fifo );
3680: }
3681:
3682: } else {
3683:
3684: //
3685: // Shouldn't get here. If we do, DON'T wake up the thread;
3686: // let it time out and reset the controller, or let another
3687: // interrupt take care of it.
3688: //
3689:
3690: FloppyDump(
3691: FLOPDBGP,
3692: ("Floppy: no result, but can't write SenseIntr\n")
3693: );
3694:
3695: controllerStateError = TRUE;
3696: }
3697: }
3698:
3699: //
3700: // We've written to the controller, and we're about to leave. On
3701: // machines with levelsensitive interrupts, we'll get another interrupt
3702: // if we RETURN before the port is flushed. To make sure that doesn't
3703: // happen, we'll do a read here.
3704: //
3705:
3706: statusByte = READ_CONTROLLER( &controllerData->ControllerAddress->Status );
3707:
3708: //
3709: // Let the interrupt settle.
3710: //
3711:
3712: KeStallExecutionProcessor(10);
3713:
3714: #ifdef KEEP_COUNTERS
3715: FloppyEndIntrTime = KeQueryPerformanceCounter((PVOID)NULL);
3716: FloppyIntrDelay = RtlLargeIntegerAdd(FloppyIntrDelay,
3717: RtlLargeIntegerSubtract(FloppyEndIntrTime,
3718: FloppyIntrTime));
3719: #endif
3720: if ( currentDeviceObject == NULL ) {
3721:
3722: //
3723: // We didn't expect this interrupt. We've dismissed it just
3724: // in case, but now return FALSE withOUT waking up the thread.
3725: //
3726:
3727: FloppyDump(
3728: FLOPDBGP,
3729: ("Floppy: unexpected interrupt\n")
3730: );
3731:
3732: return FALSE;
3733: }
3734:
3735: if ( !controllerStateError ) {
3736:
3737: //
3738: // Request a DPC for execution later to get the remainder of the
3739: // floppy state.
3740: //
3741:
3742: IoRequestDpc(
3743: currentDeviceObject,
3744: currentDeviceObject->CurrentIrp,
3745: (PVOID) NULL );
3746: }
3747:
3748: }
3749:
3750: //
3751: // We've written to the controller, and we're about to leave. On
3752: // machines with levelsensitive interrupts, we'll get another interrupt
3753: // if we RETURN before the port is flushed. To make sure that doesn't
3754: // happen, we'll do a read here.
3755: //
3756:
3757: statusByte = READ_CONTROLLER( &controllerData->ControllerAddress->Status );
3758:
3759: //
3760: // Let the interrupt settle.
3761: //
3762:
3763: KeStallExecutionProcessor(10);
3764:
3765: #ifdef KEEP_COUNTERS
3766: FloppyEndIntrTime = KeQueryPerformanceCounter((PVOID)NULL);
3767: FloppyIntrDelay = RtlLargeIntegerAdd(FloppyIntrDelay,
3768: RtlLargeIntegerSubtract(FloppyEndIntrTime,
3769: FloppyIntrTime));
3770: #endif
3771: if ( currentDeviceObject == NULL ) {
3772:
3773: //
3774: // We didn't expect this interrupt. We've dismissed it just
3775: // in case, but now return FALSE withOUT waking up the thread.
3776: //
3777:
3778: FloppyDump(
3779: FLOPDBGP,
3780: ("Floppy: unexpected interrupt\n")
3781: );
3782:
3783: return FALSE;
3784: }
3785:
3786: if ( !controllerStateError ) {
3787:
3788: //
3789: // Request a DPC for execution later to get the remainder of the
3790: // floppy state.
3791: //
3792:
3793: controllerData->IsrReentered = 0;
3794: IoRequestDpc(
3795: currentDeviceObject,
3796: currentDeviceObject->CurrentIrp,
3797: (PVOID) NULL );
3798:
3799: } else {
3800:
3801: //
3802: // Running the floppy (at least on R4000 boxes) we've seen
3803: // examples where the device interrupts, yet it never says
3804: // it *ISN'T* busy. If this ever happens on non-MCA x86 boxes
3805: // it would be ok since we use latched interrupts. Even if
3806: // the device isn't touched so that the line would be pulled
3807: // down, on the latched machine, this ISR wouldn't be called
3808: // again. The normal timeout code for a request would eventually
3809: // reset the controller and retry the request.
3810: //
3811: // On the R4000 boxes and on MCA machines, the floppy is using
3812: // level sensitive interrupts. Therefore if we don't do something
3813: // to lower the interrupt line, we will be called over and over,
3814: // *forever*. This makes it look as though the machine is hung.
3815: // Unless we were lucky enough to be on a multiprocessor, the
3816: // normal timeout code would NEVER get a chance to run because
3817: // the timeout code runs at dispatch level, and we will never
3818: // leave device level.
3819: //
3820: // What we will do is keep a counter that is incremented every
3821: // time we reach this section of code. When the counter goes
3822: // over the threshold we will do a hard reset of the device
3823: // and reset the counter down to zero. The counter will be
3824: // initialized when the device is first initialized. It will
3825: // be set to zero in the other arm of this if, and it will be
3826: // reset to zero by the normal timeout logic.
3827: //
3828:
3829: controllerData->CurrentDeviceObject = currentDeviceObject;
3830: if (controllerData->IsrReentered > FLOPPY_RESET_ISR_THRESHOLD) {
3831:
3832: //
3833: // Reset the controller. This could cause an interrupt
3834: //
3835:
3836: controllerData->IsrReentered = 0;
3837:
3838: controllerData->DriveControlImage |= DRVCTL_ENABLE_DMA_AND_INTERRUPTS;
3839: controllerData->DriveControlImage &= ~( DRVCTL_ENABLE_CONTROLLER );
3840:
3841: WRITE_CONTROLLER(
3842: &controllerData->ControllerAddress->DriveControl,
3843: controllerData->DriveControlImage );
3844:
3845: KeStallExecutionProcessor( 10 );
3846:
3847: controllerData->DriveControlImage |= DRVCTL_ENABLE_CONTROLLER;
3848:
3849: WRITE_CONTROLLER(
3850: &controllerData->ControllerAddress->DriveControl,
3851: controllerData->DriveControlImage );
3852:
3853: //
3854: // Give the device plenty of time to be reset and
3855: // interrupt again. Then just do the sense interrupt.
3856: // this should quiet the device. We will then let
3857: // the normal timeout code do its work.
3858: //
3859:
3860: KeStallExecutionProcessor(500);
3861: WRITE_CONTROLLER(
3862: &controllerData->ControllerAddress->Fifo,
3863: COMMND_SENSE_INTERRUPT );
3864: KeStallExecutionProcessor(500);
3865:
3866: KeInsertQueueDpc(
3867: &controllerData->LogErrorDpc,
3868: NULL,
3869: NULL
3870: );
3871:
3872: } else {
3873:
3874: controllerData->IsrReentered++;
3875:
3876: }
3877:
3878: }
3879: return TRUE;
3880: }
3881:
3882: VOID
3883: FloppyDeferredProcedure(
3884: IN PKDPC Dpc,
3885: IN PVOID DeferredContext,
3886: IN PVOID SystemArgument1,
3887: IN PVOID SystemArgument2
3888: )
3889:
3890: /*++
3891:
3892: Routine Description:
3893:
3894: This routine is called at DISPATCH_LEVEL by the system at the
3895: request of FloppyInterruptService(). It simply sets the interrupt
3896: event, which wakes up the floppy thread.
3897:
3898: Arguments:
3899:
3900: Dpc - a pointer to the DPC object used to invoke this routine.
3901:
3902: DeferredContext - a pointer to the device object associated with this
3903: DPC.
3904:
3905: SystemArgument1 - unused.
3906:
3907: SystemArgument2 - unused.
3908:
3909: Return Value:
3910:
3911: None.
3912:
3913: --*/
3914:
3915: {
3916: PDEVICE_OBJECT deviceObject;
3917: PDISKETTE_EXTENSION disketteExtension;
3918:
3919: UNREFERENCED_PARAMETER( Dpc );
3920: UNREFERENCED_PARAMETER( SystemArgument1 );
3921: UNREFERENCED_PARAMETER( SystemArgument2 );
3922:
3923: #ifdef KEEP_COUNTERS
3924: FloppyDPCs++;
3925: FloppyDPCTime = KeQueryPerformanceCounter((PVOID)NULL);
3926:
3927: FloppyDPCDelay = RtlLargeIntegerAdd(FloppyDPCDelay,
3928: RtlLargeIntegerSubtract(FloppyDPCTime,
3929: FloppyIntrTime));
3930: #endif
3931:
3932: deviceObject = (PDEVICE_OBJECT) DeferredContext;
3933: disketteExtension = deviceObject->DeviceExtension;
3934:
3935: KeSetEvent(
3936: &disketteExtension->ControllerData->InterruptEvent,
3937: (KPRIORITY) 0,
3938: FALSE );
3939: }
3940:
3941: NTSTATUS
3942: FlSendByte(
3943: IN UCHAR ByteToSend,
3944: IN PCONTROLLER_DATA ControllerData
3945: )
3946:
3947: /*++
3948:
3949: Routine Description:
3950:
3951: This routine is called to send a byte to the controller. It won't
3952: send the byte unless the controller is ready to receive a byte; if
3953: it's not ready after checking FIFO_TIGHTLOOP_RETRY_COUNT times, we
3954: delay for the minimum possible time (10ms) and then try again. It
3955: should always be ready after waiting 10ms.
3956:
3957: Arguments:
3958:
3959: ByteToSend - the byte to send to the controller.
3960:
3961: ControllerData - a pointer to our data area for this controller.
3962:
3963: Return Value:
3964:
3965: STATUS_SUCCESS if the byte was sent to the controller;
3966: STATUS_DEVICE_NOT_READY otherwise.
3967:
3968: --*/
3969:
3970: {
3971: ULONG i = 0;
3972: BOOLEAN byteWritten = FALSE;
3973:
3974: //
3975: // Sit in a tight loop for a while. If the controller becomes ready,
3976: // send the byte.
3977: //
3978:
3979: do {
3980:
3981: if ( ( READ_CONTROLLER( &ControllerData->ControllerAddress->Status )
3982: & STATUS_IO_READY_MASK ) == STATUS_WRITE_READY ) {
3983:
3984: WRITE_CONTROLLER(
3985: &ControllerData->ControllerAddress->Fifo,
3986: ByteToSend );
3987:
3988: byteWritten = TRUE;
3989:
3990: }
3991:
3992: i++;
3993:
3994: } while ( (!byteWritten) && ( i < FIFO_TIGHTLOOP_RETRY_COUNT ) );
3995:
3996: //
3997: // We hope that in most cases the FIFO will become ready very quickly
3998: // and the above loop will have written the byte. But if the FIFO
3999: // is not yet ready, we'll loop a few times delaying for 10ms and then
4000: // try it again.
4001: //
4002:
4003: i = 0;
4004:
4005: while ( ( !byteWritten ) && ( i < FIFO_DELAY_RETRY_COUNT ) ) {
4006:
4007: FloppyDump(
4008: FLOPINFO,
4009: ("Floppy: waiting for 10ms for controller write\n")
4010: );
4011:
4012: KeDelayExecutionThread(
4013: KernelMode,
4014: FALSE,
4015: &ControllerData->Minimum10msDelay );
4016:
4017: i++;
4018:
4019: if ( (READ_CONTROLLER( &ControllerData->ControllerAddress->Status )
4020: & STATUS_IO_READY_MASK) == STATUS_WRITE_READY ) {
4021:
4022: WRITE_CONTROLLER(
4023: &ControllerData->ControllerAddress->Fifo,
4024: ByteToSend );
4025:
4026: byteWritten = TRUE;
4027: }
4028: }
4029:
4030: if ( byteWritten ) {
4031:
4032: return STATUS_SUCCESS;
4033:
4034: } else {
4035:
4036: //
4037: // We've waited over 30ms, and the FIFO *still* isn't ready.
4038: // Return an error.
4039: //
4040:
4041: FloppyDump(
4042: FLOPWARN,
4043: ("Floppy: FIFO not ready to write after 30ms\n")
4044: );
4045:
4046: ControllerData->HardwareFailed = TRUE;
4047:
4048: return STATUS_DEVICE_NOT_READY;
4049: }
4050: }
4051:
4052: NTSTATUS
4053: FlGetByte(
4054: OUT PUCHAR ByteToGet,
4055: IN PCONTROLLER_DATA ControllerData
4056: )
4057:
4058: /*++
4059:
4060: Routine Description:
4061:
4062: This routine is called to get a byte from the controller. It won't
4063: read the byte unless the controller is ready to send a byte; if
4064: it's not ready after checking FIFO_RETRY_COUNT times, we delay for
4065: the minimum possible time (10ms) and then try again. It should
4066: always be ready after waiting 10ms.
4067:
4068: Arguments:
4069:
4070: ByteToGet - the address in which the byte read from the controller
4071: is stored.
4072:
4073: ControllerData - a pointer to our data area for this controller.
4074:
4075: Return Value:
4076:
4077: STATUS_SUCCESS if a byte was read from the controller;
4078: STATUS_DEVICE_NOT_READY otherwise.
4079:
4080: --*/
4081:
4082: {
4083: ULONG i = 0;
4084: BOOLEAN byteRead = FALSE;
4085:
4086: //
4087: // Sit in a tight loop for a while. If the controller becomes ready,
4088: // read the byte.
4089: //
4090:
4091: do {
4092:
4093: if ( ( READ_CONTROLLER( &ControllerData->ControllerAddress->Status )
4094: & STATUS_IO_READY_MASK ) == STATUS_READ_READY ) {
4095:
4096: *ByteToGet = READ_CONTROLLER(
4097: &ControllerData->ControllerAddress->Fifo );
4098:
4099: byteRead = TRUE;
4100:
4101: }
4102:
4103: i++;
4104:
4105: } while ( ( !byteRead ) && ( i < FIFO_TIGHTLOOP_RETRY_COUNT ) );
4106:
4107: //
4108: // We hope that in most cases the FIFO will become ready very quickly
4109: // and the above loop will have read the byte. But if the FIFO
4110: // is not yet ready, we'll loop a few times delaying for 10ms and then
4111: // trying it again.
4112: //
4113:
4114: i = 0;
4115:
4116: while ( ( !byteRead ) && ( i < FIFO_DELAY_RETRY_COUNT ) ) {
4117:
4118: FloppyDump(
4119: FLOPINFO,
4120: ("Floppy: waiting for 10ms for controller read\n")
4121: );
4122:
4123: KeDelayExecutionThread(
4124: KernelMode,
4125: FALSE,
4126: &ControllerData->Minimum10msDelay );
4127:
4128: i++;
4129:
4130: if ( (READ_CONTROLLER( &ControllerData->ControllerAddress->Status )
4131: & STATUS_IO_READY_MASK) == STATUS_READ_READY ) {
4132:
4133: *ByteToGet = READ_CONTROLLER(
4134: &ControllerData->ControllerAddress->Fifo );
4135:
4136: byteRead = TRUE;
4137:
4138: }
4139: }
4140:
4141: if ( byteRead ) {
4142:
4143: return STATUS_SUCCESS;
4144:
4145: } else {
4146:
4147: //
4148: // We've waited over 30ms, and the FIFO *still* isn't ready.
4149: // Return an error.
4150: //
4151:
4152: FloppyDump(
4153: FLOPWARN,
4154: ("Floppy: FIFO not ready to read after 30ms\n")
4155: );
4156:
4157: ControllerData->HardwareFailed = TRUE;
4158:
4159: return STATUS_DEVICE_NOT_READY;
4160: }
4161:
4162: }
4163:
4164: NTSTATUS
4165: FlInterpretError(
4166: IN UCHAR StatusRegister1,
4167: IN UCHAR StatusRegister2
4168: )
4169:
4170: /*++
4171:
4172: Routine Description:
4173:
4174: This routine is called when the floppy controller returns an error.
4175: Status registers 1 and 2 are passed in, and this returns an appropriate
4176: error status.
4177:
4178: Arguments:
4179:
4180: StatusRegister1 - the controller's status register #1.
4181:
4182: StatusRegister2 - the controller's status register #2.
4183:
4184: Return Value:
4185:
4186: An NTSTATUS error determined from the status registers.
4187:
4188: --*/
4189:
4190: {
4191: if ( ( StatusRegister1 & STREG1_CRC_ERROR ) ||
4192: ( StatusRegister2 & STREG2_CRC_ERROR ) ) {
4193:
4194: return STATUS_CRC_ERROR;
4195: }
4196:
4197: if ( StatusRegister1 & STREG1_DATA_OVERRUN ) {
4198:
4199: return STATUS_DATA_OVERRUN;
4200: }
4201:
4202: if ( ( StatusRegister1 & STREG1_SECTOR_NOT_FOUND ) ||
4203: ( StatusRegister1 & STREG1_END_OF_DISKETTE ) ) {
4204:
4205: return STATUS_NONEXISTENT_SECTOR;
4206: }
4207:
4208: if ( ( StatusRegister2 & STREG2_DATA_NOT_FOUND ) ||
4209: ( StatusRegister2 & STREG2_BAD_CYLINDER ) ||
4210: ( StatusRegister2 & STREG2_DELETED_DATA ) ) {
4211:
4212: return STATUS_DEVICE_DATA_ERROR;
4213: }
4214:
4215: if ( StatusRegister1 & STREG1_WRITE_PROTECTED ) {
4216:
4217: return STATUS_MEDIA_WRITE_PROTECTED;
4218: }
4219:
4220: if ( StatusRegister1 & STREG1_ID_NOT_FOUND ) {
4221:
4222: return STATUS_FLOPPY_ID_MARK_NOT_FOUND;
4223:
4224: }
4225:
4226: if ( StatusRegister2 & STREG2_WRONG_CYLINDER ) {
4227:
4228: return STATUS_FLOPPY_WRONG_CYLINDER;
4229:
4230: }
4231:
4232: //
4233: // There's other error bits, but no good status values to map them
4234: // to. Just return a generic one.
4235: //
4236:
4237: return STATUS_FLOPPY_UNKNOWN_ERROR;
4238: }
4239:
4240: BOOLEAN
4241: FlClearIsrReentered(
4242: IN PVOID Context
4243: )
4244:
4245: /*++
4246:
4247: Routine Description:
4248:
4249: This routine is simply used to clear the reentered count of the isr.
4250:
4251: Arguments:
4252:
4253: Context - Simply a pointer to the re-entered count of the isr.
4254:
4255: Return Value:
4256:
4257: Always False.
4258:
4259: --*/
4260:
4261: {
4262:
4263: *((ULONG *)Context) = 0;
4264: return FALSE;
4265:
4266: }
4267:
4268: VOID
4269: FlFinishOperation(
4270: IN OUT PIRP Irp,
4271: IN PDISKETTE_EXTENSION DisketteExtension
4272: )
4273:
4274: /*++
4275:
4276: Routine Description:
4277:
4278: This routine is called by FloppyThread at the end of any operation
4279: whether it succeeded or not.
4280:
4281: If the packet is failing due to a hardware error, this routine will
4282: reinitialize the hardware and retry once.
4283:
4284: When the packet is done, this routine will start the timer to turn
4285: off the motor, and complete the IRP.
4286:
4287: Arguments:
4288:
4289: Irp - a pointer to the IO Request Packet being processed.
4290:
4291: DisketteExtension - a pointer to the diskette extension for the
4292: diskette on which the operation occurred.
4293:
4294: Return Value:
4295:
4296: None.
4297:
4298: --*/
4299:
4300: {
4301: KIRQL oldIrql;
4302: PCONTROLLER_DATA controllerData;
4303: NTSTATUS ntStatus;
4304: UCHAR driveStatus;
4305:
4306: FloppyDump(
4307: FLOPSHOW,
4308: ("Floppy: FloppyFinishOperation...\n")
4309: );
4310:
4311: controllerData = DisketteExtension->ControllerData;
4312:
4313: //
4314: // See if this packet is being failed due to a hardware error.
4315: //
4316:
4317: if ( ( Irp->IoStatus.Status != STATUS_SUCCESS ) &&
4318: ( controllerData->HardwareFailed ) ) {
4319:
4320: controllerData->HardwareFailCount++;
4321:
4322: if ( controllerData->HardwareFailCount < HARDWARE_RESET_RETRY_COUNT ) {
4323:
4324: KeSynchronizeExecution(
4325: controllerData->InterruptObject,
4326: FlClearIsrReentered,
4327: &controllerData->IsrReentered
4328: );
4329: //
4330: // This is our first time through (that is, we're not retrying
4331: // the packet after a hardware failure). If it failed this first
4332: // time because of a hardware problem, set the HardwareFailed flag
4333: // and put the IRP at the beginning of the request queue.
4334: //
4335:
4336: ntStatus = FlInitializeControllerHardware(
4337: controllerData,
4338: DisketteExtension->DeviceObject );
4339:
4340: if ( NT_SUCCESS( ntStatus ) ) {
4341:
4342: FloppyDump(
4343: FLOPINFO,
4344: ("Floppy: packet failed; hardware reset. Retry.\n")
4345: );
4346:
4347: //
4348: // Force media to be redetermined, in case we messed up
4349: // and to make sure FlDatarateSpecifyConfigure() gets
4350: // called.
4351: //
4352:
4353: DisketteExtension->MediaType = Undetermined;
4354:
4355: FloppyDump(
4356: FLOPIRPPATH,
4357: ("Floppy: irp %x failed - back on the queue with it\n",
4358: Irp)
4359: );
4360: ExInterlockedInsertHeadList(
4361: &controllerData->ListEntry,
4362: &Irp->Tail.Overlay.ListEntry,
4363: &controllerData->ListSpinLock );
4364:
4365: return;
4366: }
4367:
4368: FloppyDump(
4369: FLOPDBGP,
4370: ("Floppy: packet AND hardware reset failed.\n")
4371: );
4372: }
4373:
4374: }
4375:
4376: //
4377: // If we didn't already RETURN, we're done with this packet so
4378: // reset the HardwareFailCount for the next packet.
4379: //
4380:
4381: controllerData->HardwareFailCount = 0;
4382:
4383: //
4384: // If there's a motor on, set the timer so that it will be turned off
4385: // in a couple of seconds if nobody uses it.
4386: //
4387:
4388: driveStatus = controllerData->DriveControlImage;
4389:
4390: if ( ( driveStatus & DRVCTL_MOTOR_MASK ) != 0 ) {
4391:
4392: KeAcquireSpinLock( &controllerData->TimerSpinLock, &oldIrql );
4393:
4394: driveStatus = controllerData->DriveControlImage;
4395:
4396: if ( ( driveStatus & DRVCTL_MOTOR_MASK ) != 0 ) {
4397:
4398: controllerData->MotorTimer = TIMER_START;
4399: }
4400:
4401: KeReleaseSpinLock( &controllerData->TimerSpinLock, oldIrql );
4402: }
4403:
4404: //
4405: // If this request was unsuccessful and the error is one that can be
4406: // remedied by the user, save the Device Object so that the file system,
4407: // after reaching its original entry point, can know the real device.
4408: //
4409:
4410: if ( !NT_SUCCESS( Irp->IoStatus.Status ) &&
4411: IoIsErrorUserInduced( Irp->IoStatus.Status ) ) {
4412:
4413: IoSetHardErrorOrVerifyDevice( Irp, DisketteExtension->DeviceObject );
4414: }
4415:
4416: //
4417: // Even if the operation failed, it probably had to wait for the drive
4418: // to spin up or somesuch so we'll always complete the request with the
4419: // standard priority boost.
4420: //
4421:
4422: if ( ( Irp->IoStatus.Status != STATUS_SUCCESS ) &&
4423: ( Irp->IoStatus.Status != STATUS_VERIFY_REQUIRED ) &&
4424: ( Irp->IoStatus.Status != STATUS_NO_MEDIA_IN_DEVICE ) ) {
4425:
4426: FloppyDump(
4427: FLOPDBGP,
4428: ("Floppy: IRP failed with error %lx\n", Irp->IoStatus.Status)
4429: );
4430:
4431: } else {
4432:
4433: FloppyDump(
4434: FLOPINFO,
4435: ("Floppy: IoStatus.Status = %x\n", Irp->IoStatus.Status)
4436: );
4437: }
4438:
4439: FloppyDump(
4440: FLOPINFO,
4441: ("Floppy: IoStatus.Information = %x\n", Irp->IoStatus.Information)
4442: );
4443:
4444: FloppyDump(
4445: FLOPIRPPATH,
4446: ("Floppy: Finishing up IRP: %x\n",Irp)
4447: );
4448: IoCompleteRequest( Irp, IO_DISK_INCREMENT );
4449: }
4450:
4451: VOID
4452: FloppyMotorOffDpc(
4453: IN PDEVICE_OBJECT DeviceObject,
4454: IN PVOID Context
4455: )
4456:
4457: /*++
4458:
4459: Routine Description:
4460:
4461: This routine is called at DISPATCH_LEVEL once every second by the
4462: I/O system.
4463:
4464: If the timer is "set" (greater than 0) this routine will decrement
4465: it. If it ever reaches 0, the running motor is turned off.
4466:
4467: Arguments:
4468:
4469: DeviceObject - a pointer to the device object associated with this
4470: timer (always the first disk on the controller).
4471:
4472: Context - unused.
4473:
4474: Return Value:
4475:
4476: None.
4477:
4478: --*/
4479:
4480: {
4481: KIRQL oldIrql;
4482: PDISKETTE_EXTENSION disketteExtension;
4483: PCONTROLLER_DATA controllerData;
4484:
4485: UNREFERENCED_PARAMETER( Context );
4486:
4487: disketteExtension = (PDISKETTE_EXTENSION) DeviceObject->DeviceExtension;
4488: controllerData = disketteExtension->ControllerData;
4489:
4490: if ( controllerData->MotorTimer != TIMER_CANCEL ) {
4491:
4492: //
4493: // One of the motors is running - grab the timer spinlock and
4494: // decrement the timer counter. If it expires, turn off the
4495: // motor.
4496: //
4497:
4498: KeAcquireSpinLock( &controllerData->TimerSpinLock, &oldIrql );
4499:
4500: if ( controllerData->MotorTimer != TIMER_CANCEL ) {
4501:
4502: controllerData->MotorTimer--;
4503:
4504: if ( controllerData->MotorTimer == TIMER_EXPIRED ) {
4505:
4506: controllerData->MotorTimer = TIMER_CANCEL;
4507:
4508: controllerData->DriveControlImage =
4509: DRVCTL_ENABLE_DMA_AND_INTERRUPTS +
4510: DRVCTL_ENABLE_CONTROLLER;
4511:
4512: WRITE_CONTROLLER(
4513: &controllerData->ControllerAddress->DriveControl,
4514: controllerData->DriveControlImage );
4515: }
4516: }
4517:
4518: KeReleaseSpinLock( &controllerData->TimerSpinLock, oldIrql );
4519: }
4520: }
4521:
4522: NTSTATUS
4523: FlIssueCommand(
4524: IN UCHAR Command,
4525: IN OUT PDISKETTE_EXTENSION DisketteExtension
4526: )
4527:
4528: /*++
4529:
4530: Routine Description:
4531:
4532: This routine sends the command and all parameters to the controller,
4533: waits for the command to interrupt if necessary, and reads the result
4534: bytes from the controller, if any.
4535:
4536: Before calling this routine, the caller should put the parameters for
4537: the command in ControllerData->FifoBuffer[]. The result bytes will
4538: be returned in the same place.
4539:
4540: This routine runs off the CommandTable. For each command, this says
4541: how many parameters there are, whether or not there is an interrupt
4542: to wait for, and how many result bytes there are. Note that commands
4543: without result bytes actually have two, since the ISR will issue a
4544: SENSE INTERRUPT STATUS command on their behalf.
4545:
4546: Arguments:
4547:
4548: Command - a byte specifying the command to be sent to the controller.
4549:
4550: DisketteExtension - a pointer to our data area for the drive being
4551: accessed (any drive if a controller command is being given).
4552:
4553: Return Value:
4554:
4555: STATUS_SUCCESS if the command was sent and bytes received properly;
4556: appropriate error propogated otherwise.
4557:
4558: --*/
4559:
4560: {
4561: PCONTROLLER_DATA controllerData;
4562: NTSTATUS ntStatus;
4563: NTSTATUS ntStatus2;
4564: UCHAR i;
4565:
4566: FloppyDump(
4567: FLOPSHOW,
4568: ("Floppy: FloppyIssueCommand...\n")
4569: );
4570:
4571: controllerData = DisketteExtension->ControllerData;
4572:
4573: //
4574: // If this command causes an interrupt, set CurrentDeviceObject and
4575: // reset the interrupt event.
4576: //
4577:
4578: if ( CommandTable[Command & COMMAND_MASK].InterruptExpected ) {
4579:
4580: controllerData->CurrentDeviceObject = DisketteExtension->DeviceObject;
4581:
4582: controllerData->CommandHasResultPhase =
4583: !!CommandTable[Command & COMMAND_MASK].FirstResultByte;
4584:
4585: KeResetEvent( &controllerData->InterruptEvent );
4586: }
4587:
4588: //
4589: // Send the command to the controller.
4590: //
4591:
4592: ntStatus = FlSendByte( Command, controllerData );
4593:
4594: //
4595: // If the command was successfully sent, we can proceed.
4596: //
4597:
4598: if ( NT_SUCCESS( ntStatus ) ) {
4599:
4600: //
4601: // Send the parameters as long as we succeed.
4602: //
4603:
4604: for ( i = 0;
4605: ( i < CommandTable[Command & COMMAND_MASK].NumberOfParameters ) &&
4606: ( NT_SUCCESS( ntStatus ) );
4607: i++ ) {
4608:
4609: ntStatus = FlSendByte(
4610: controllerData->FifoBuffer[i],
4611: controllerData );
4612: }
4613:
4614: if ( NT_SUCCESS( ntStatus ) ) {
4615:
4616: //
4617: // If there is an interrupt, wait for it.
4618: //
4619:
4620: if ( CommandTable[Command & COMMAND_MASK].InterruptExpected ) {
4621:
4622: ntStatus = KeWaitForSingleObject(
4623: &controllerData->InterruptEvent,
4624: Executive,
4625: KernelMode,
4626: FALSE,
4627: &controllerData->InterruptDelay );
4628:
4629: if ( ntStatus == STATUS_TIMEOUT ) {
4630:
4631: //
4632: // Change info to an error. We'll just say
4633: // that the device isn't ready.
4634: //
4635:
4636: ntStatus = STATUS_DEVICE_NOT_READY;
4637:
4638: controllerData->HardwareFailed = TRUE;
4639: }
4640: #ifdef KEEP_COUNTERS
4641: FloppyThreadTime = KeQueryPerformanceCounter((PVOID)NULL);
4642: FloppyThreadDelay = RtlLargeIntegerAdd(FloppyThreadDelay,
4643: RtlLargeIntegerSubtract(FloppyThreadTime,
4644: FloppyDPCTime));
4645: FloppyFromIntrDelay = RtlLargeIntegerAdd(FloppyFromIntrDelay,
4646: RtlLargeIntegerSubtract(FloppyThreadTime,
4647: FloppyIntrTime));
4648: FloppyThreadWake++;
4649: #endif
4650: }
4651:
4652: //
4653: // If successful so far, get the result bytes.
4654: //
4655:
4656: if ( NT_SUCCESS( ntStatus ) ) {
4657:
4658: for ( i = CommandTable[Command & COMMAND_MASK].FirstResultByte;
4659: ( i < CommandTable[Command & COMMAND_MASK].
4660: NumberOfResultBytes ) && ( NT_SUCCESS( ntStatus ) );
4661: i++ ) {
4662:
4663: ntStatus = FlGetByte(
4664: &controllerData->FifoBuffer[i],
4665: controllerData );
4666: }
4667: }
4668: }
4669: }
4670:
4671: //
4672: // If there was a problem, check to see if it was caused by an
4673: // unimplemented command.
4674: //
4675:
4676: if ( !NT_SUCCESS( ntStatus ) ) {
4677:
4678: if ( ( i == 1 ) &&
4679: ( !CommandTable[Command & COMMAND_MASK].AlwaysImplemented ) ) {
4680:
4681: //
4682: // This error is probably caused by a command that's not
4683: // implemented on this controller. Read the error from the
4684: // controller, and we should be in a stable state.
4685: //
4686:
4687: ntStatus2 = FlGetByte(
4688: &controllerData->FifoBuffer[0],
4689: controllerData );
4690:
4691: //
4692: // If GetByte went as planned, we'll return the original error.
4693: //
4694:
4695: if ( NT_SUCCESS( ntStatus2 ) ) {
4696:
4697: if ( controllerData->FifoBuffer[0] !=
4698: STREG0_END_INVALID_COMMAND ) {
4699:
4700: //
4701: // Status isn't as we expect, so return generic error.
4702: //
4703:
4704: ntStatus = STATUS_FLOPPY_BAD_REGISTERS;
4705:
4706: controllerData->HardwareFailed = TRUE;
4707: }
4708:
4709: } else {
4710:
4711: //
4712: // GetByte returned an error, so propogate THAT.
4713: //
4714:
4715: ntStatus = ntStatus2;
4716: }
4717: }
4718: }
4719:
4720: if ( !NT_SUCCESS( ntStatus ) ) {
4721:
4722: //
4723: // Print an error message unless the command isn't always
4724: // implemented, ie CONFIGURE.
4725: //
4726:
4727: if ( !( ( ntStatus == STATUS_DEVICE_NOT_READY ) &&
4728: ( !CommandTable[Command & COMMAND_MASK].AlwaysImplemented ) ) ) {
4729:
4730: FloppyDump(
4731: FLOPDBGP,
4732: ("Floppy: err %x "
4733: "------ while giving command %x\n",
4734: ntStatus,
4735: Command)
4736: );
4737: }
4738: }
4739:
4740: return ntStatus;
4741: }
4742:
4743: NTSTATUS
4744: FlStartDrive(
4745: IN OUT PDISKETTE_EXTENSION DisketteExtension,
4746: IN BOOLEAN WriteOperation,
4747: IN BOOLEAN SetUpMedia,
4748: IN BOOLEAN IgnoreChange
4749: )
4750:
4751: /*++
4752:
4753: Routine Description:
4754:
4755: This routine is called at the beginning of every operation. It cancels
4756: the motor timer if it's on, turns the motor on and waits for it to
4757: spin up if it was off, resets the disk change line and returns
4758: VERIFY_REQUIRED if the disk has been changed, determines the diskette
4759: media type if it's not known and SetUpMedia=TRUE, and makes sure that
4760: the disk isn't write protected if WriteOperation = TRUE.
4761:
4762: Arguments:
4763:
4764: DisketteExtension - a pointer to our data area for the drive being
4765: started.
4766:
4767: WriteOperation - TRUE if the diskette will be written to, FALSE
4768: otherwise.
4769:
4770: SetUpMedia - TRUE if the media type of the diskette in the drive
4771: should be determined.
4772:
4773: IgnoreChange - Do not return VERIFY_REQUIRED eventhough we are mounting
4774: for the first time.
4775:
4776: Return Value:
4777:
4778: STATUS_SUCCESS if the drive is started properly; appropriate error
4779: propogated otherwise.
4780:
4781: --*/
4782:
4783: {
4784: LARGE_INTEGER motorOnDelay;
4785: KIRQL oldIrql;
4786: PCONTROLLER_DATA controllerData;
4787: NTSTATUS ntStatus = STATUS_SUCCESS;
4788: USHORT timeToWait;
4789: UCHAR driveStatus;
4790: BOOLEAN motorStarted = FALSE;
4791:
4792: FloppyDump(
4793: FLOPSHOW,
4794: ("Floppy: FloppyStartDrive...\n")
4795: );
4796:
4797: //
4798: // IMPORTANT
4799: // NOTE
4800: // COMMENT
4801: //
4802: // Here we will copy the BIOS floppy configuration on top of the
4803: // highest media value in our global array so that any type of processing
4804: // that will recalibrate the drive can have it done here.
4805: // An optimization would be to only do it when we will try to recalibrate
4806: // the driver or media in it.
4807: // At this point, we ensure that on any processing of a command we
4808: // are going to have the real values inthe first entry of the array for
4809: // driver constants.
4810: //
4811:
4812: DriveMediaConstants[DriveMediaLimits[DisketteExtension->DriveType].
4813: HighestDriveMediaType] = DisketteExtension->BiosDriveMediaConstants;
4814:
4815:
4816:
4817: controllerData = DisketteExtension->ControllerData;
4818:
4819: if ( ( controllerData->CreatedArtificialDrive ) &&
4820: ( controllerData->LastDisketteExtension != DisketteExtension ) ) {
4821:
4822: //
4823: // There's an artificial drive, and the user has switched, so
4824: // pretend there's no media so the user will be prompted to
4825: // insert the other diskette.
4826: //
4827:
4828: controllerData->LastDisketteExtension = DisketteExtension;
4829: DisketteExtension->ArtificialVerifyRequired = TRUE;
4830:
4831: FloppyDump(
4832: FLOPSHOW,
4833: ("Floppy: start drive - artificial drive needs verification\n")
4834: );
4835: return STATUS_NO_MEDIA_IN_DEVICE;
4836: }
4837:
4838: //
4839: // There is no override of the artifically induced verify.
4840: //
4841:
4842: if ( DisketteExtension->ArtificialVerifyRequired == TRUE ) {
4843:
4844: if ( DisketteExtension->DeviceObject->Vpb->Flags & VPB_MOUNTED ) {
4845:
4846: DisketteExtension->DeviceObject->Flags |= DO_VERIFY_VOLUME;
4847: }
4848:
4849: DisketteExtension->ArtificialVerifyRequired = FALSE;
4850: FloppyDump(
4851: FLOPSHOW,
4852: ("Floppy: start drive - artificial verify required\n")
4853: );
4854: return STATUS_VERIFY_REQUIRED;
4855: }
4856:
4857: //
4858: // Grab the timer spin lock and cancel the timer, since we want the
4859: // motor to run for the whole operation. If the proper drive is
4860: // already running, great; if not, start the motor and wait for it
4861: // to spin up.
4862: //
4863:
4864: KeAcquireSpinLock( &controllerData->TimerSpinLock, &oldIrql );
4865:
4866: controllerData->MotorTimer = TIMER_CANCEL;
4867:
4868: driveStatus = controllerData->DriveControlImage;
4869:
4870: if ( driveStatus != DisketteExtension->DriveOnValue ) {
4871:
4872: controllerData->DriveControlImage = DisketteExtension->DriveOnValue;
4873:
4874: WRITE_CONTROLLER(
4875: &controllerData->ControllerAddress->DriveControl,
4876: controllerData->DriveControlImage );
4877:
4878: //
4879: // If this the drive media is unknown, initialize the diskette
4880: // extension. This is done to get the time to wait value so use
4881: // the slowest and oldest drive type.
4882: //
4883:
4884: if ((DisketteExtension->MediaType == Undetermined) ||
4885: (DisketteExtension->MediaType == Unknown)) {
4886:
4887: DisketteExtension->DriveMediaConstants = DriveMediaConstants[0];
4888: }
4889:
4890: KeReleaseSpinLock( &controllerData->TimerSpinLock, oldIrql );
4891:
4892: //
4893: // Wait the appropriate length of time for the drive to spin up.
4894: //
4895:
4896: if ( WriteOperation ) {
4897:
4898: timeToWait = DisketteExtension->DriveMediaConstants.MotorSettleTimeWrite;
4899:
4900: } else {
4901:
4902: timeToWait = DisketteExtension->DriveMediaConstants.MotorSettleTimeRead;
4903: }
4904:
4905: FloppyDump(
4906: FLOPSHOW,
4907: ("Floppy: Waiting for motor to spin up (0x%x)...\n", timeToWait)
4908: );
4909:
4910: motorOnDelay.LowPart = - ( 10 * 1000 * timeToWait );
4911: motorOnDelay.HighPart = -1;
4912:
4913: KeDelayExecutionThread( KernelMode, FALSE, &motorOnDelay );
4914:
4915: motorStarted = TRUE;
4916:
4917: } else {
4918:
4919: KeReleaseSpinLock( &controllerData->TimerSpinLock, oldIrql );
4920:
4921: }
4922:
4923: driveStatus = READ_CONTROLLER(
4924: &controllerData->ControllerAddress->DRDC.DiskChange );
4925:
4926: //
4927: // Support for 360K drives:
4928: // They have no change line, so we will assume a power up of the motor
4929: // to be equivalent to a change of floppy (we assume noone will
4930: // change the floppy while it is turning.
4931: // So force a VERIFY here (unless the file system explicitly turned
4932: // it off).
4933: //
4934:
4935: if ( ((DisketteExtension->DriveType == DRIVE_TYPE_0360) &&
4936: motorStarted) ||
4937: ((DisketteExtension->DriveType != DRIVE_TYPE_0360) &&
4938: (driveStatus & DSKCHG_DISKETTE_REMOVED)) ) {
4939:
4940: FloppyDump(
4941: FLOPSHOW,
4942: ("Floppy: disk changed...\n")
4943: );
4944:
4945: DisketteExtension->MediaType = Undetermined;
4946:
4947: //
4948: // If the volume is mounted, we must tell the filesystem to
4949: // verify that the media in the drive is the same volume.
4950: //
4951:
4952: if ( DisketteExtension->DeviceObject->Vpb->Flags & VPB_MOUNTED ) {
4953:
4954: DisketteExtension->DeviceObject->Flags |= DO_VERIFY_VOLUME;
4955:
4956: }
4957:
4958: //
4959: // Only go through the device reset if we did get the flag set
4960: // We really only want to go throught here if the diskette changed,
4961: // but on 360 it will always say the diskette has changed.
4962: // So based on our previous test, only proceed if it is NOT
4963: // a 360K driver
4964:
4965: // if ( driveStatus & DSKCHG_DISKETTE_REMOVED ) {
4966:
4967: if (DisketteExtension->DriveType != DRIVE_TYPE_0360) {
4968:
4969: //
4970: // Now seek twice to reset the "disk changed" line. First
4971: // seek to 1.
4972: //
4973: // Normally we'd do a READ ID after a seek. However, we don't
4974: // even know if this disk is formatted. We're not really
4975: // trying to get anywhere; we're just doing this to reset the
4976: // "disk changed" line so we'll skip the READ ID.
4977: //
4978:
4979: controllerData->FifoBuffer[0] = DisketteExtension->DeviceUnit;
4980: controllerData->FifoBuffer[1] = 1;
4981:
4982: ntStatus = FlIssueCommand( COMMND_SEEK, DisketteExtension );
4983:
4984: if ( !NT_SUCCESS( ntStatus ) ) {
4985:
4986: FloppyDump(
4987: FLOPWARN,
4988: ("Floppy: seek to 1 returned %x\n", ntStatus)
4989: );
4990:
4991: return ntStatus;
4992:
4993: } else {
4994:
4995: if ( !( controllerData->FifoBuffer[0] & STREG0_SEEK_COMPLETE )
4996: || ( controllerData->FifoBuffer[1] != 1 ) ) {
4997:
4998: FloppyDump(
4999: FLOPWARN,
5000: ("Floppy: Seek to 1 had bad return registers\n")
5001: );
5002:
5003: controllerData->HardwareFailed = TRUE;
5004:
5005: return STATUS_FLOPPY_BAD_REGISTERS;
5006: }
5007: }
5008:
5009: //
5010: // Seek back to 0. We can once again skip the READ ID.
5011: //
5012:
5013: controllerData->FifoBuffer[0] = DisketteExtension->DeviceUnit;
5014: controllerData->FifoBuffer[1] = 0;
5015:
5016: ntStatus = FlIssueCommand( COMMND_SEEK, DisketteExtension );
5017:
5018: if ( !NT_SUCCESS( ntStatus ) ) {
5019:
5020: FloppyDump(
5021: FLOPWARN,
5022: ("Floppy: seek to 0 returned %x\n", ntStatus)
5023: );
5024:
5025: return ntStatus;
5026:
5027: } else {
5028:
5029: if ( !( controllerData->FifoBuffer[0] & STREG0_SEEK_COMPLETE )
5030: || ( controllerData->FifoBuffer[1] != 0 ) ) {
5031:
5032: FloppyDump(
5033: FLOPWARN,
5034: ("Floppy: Seek to 0 had bad return registers\n")
5035: );
5036:
5037: controllerData->HardwareFailed = TRUE;
5038:
5039: return STATUS_FLOPPY_BAD_REGISTERS;
5040: }
5041: }
5042:
5043: driveStatus = READ_CONTROLLER(
5044: &controllerData->ControllerAddress->DRDC.DiskChange );
5045:
5046: if ( driveStatus & DSKCHG_DISKETTE_REMOVED ) {
5047:
5048: //
5049: // If "disk changed" is still set after the double seek, the
5050: // drive door must be opened.
5051: //
5052:
5053: FloppyDump(
5054: FLOPINFO,
5055: ("Floppy: close the door!\n")
5056: );
5057:
5058: //
5059: // Turn off the flag for now so that we will not get so many
5060: // gratuitous verifys. It will be set again the next time.
5061: //
5062:
5063: if ( DisketteExtension->DeviceObject->Vpb->Flags & VPB_MOUNTED ) {
5064:
5065: DisketteExtension->DeviceObject->Flags &= ~DO_VERIFY_VOLUME;
5066:
5067: }
5068:
5069: return STATUS_NO_MEDIA_IN_DEVICE;
5070: }
5071: }
5072:
5073: //
5074: // IgnoreChange indicates the file system is in the process
5075: // of performing a verify so do not return verify required.
5076: //
5077:
5078: if (( IgnoreChange == FALSE ) &&
5079: ( DisketteExtension->DeviceObject->Vpb->Flags & VPB_MOUNTED )) {
5080:
5081: //
5082: // Drive WAS mounted, but door was opened since the last time
5083: // we checked so tell the file system to verify the diskette.
5084: //
5085:
5086: FloppyDump(
5087: FLOPSHOW,
5088: ("Floppy: start drive - verify required because door opened\n")
5089: );
5090:
5091: return STATUS_VERIFY_REQUIRED;
5092: }
5093: }
5094:
5095: if ( SetUpMedia ) {
5096:
5097: if ( DisketteExtension->MediaType == Undetermined ) {
5098:
5099: ntStatus = FlDetermineMediaType( DisketteExtension );
5100:
5101: } else {
5102:
5103: if ( DisketteExtension->MediaType == Unknown ) {
5104:
5105: //
5106: // We've already tried to determine the media type and
5107: // failed. It's probably not formatted.
5108: //
5109:
5110: FloppyDump(
5111: FLOPSHOW,
5112: ("Floppy - start drive - media type was unknown\n")
5113: );
5114: return STATUS_UNRECOGNIZED_MEDIA;
5115:
5116: } else {
5117:
5118: if ( DisketteExtension->DriveMediaType !=
5119: controllerData->LastDriveMediaType ) {
5120:
5121: //
5122: // Last drive/media combination accessed by the
5123: // controller was different, so set up the controller.
5124: //
5125:
5126: ntStatus = FlDatarateSpecifyConfigure( DisketteExtension );
5127: if (!NT_SUCCESS(ntStatus)) {
5128:
5129: FloppyDump(
5130: FLOPWARN,
5131: ("Floppy: start drive - bad status from datarate"
5132: "------ specify %x\n",
5133: ntStatus)
5134: );
5135:
5136: }
5137: }
5138: }
5139: }
5140: }
5141:
5142: //
5143: // If this is a WRITE, check the drive to make sure it's not write
5144: // protected. If so, return an error.
5145: //
5146:
5147: if ( ( WriteOperation ) && ( NT_SUCCESS( ntStatus ) ) ) {
5148:
5149: controllerData->FifoBuffer[0] = DisketteExtension->DeviceUnit;
5150:
5151: ntStatus = FlIssueCommand( COMMND_SENSE_DRIVE, DisketteExtension );
5152:
5153: if ( !NT_SUCCESS( ntStatus ) ) {
5154:
5155: FloppyDump(
5156: FLOPWARN,
5157: ("Floppy: SENSE_DRIVE returned %x\n", ntStatus)
5158: );
5159:
5160: return ntStatus;
5161: }
5162:
5163: if ( controllerData->FifoBuffer[0] & STREG3_WRITE_PROTECTED ) {
5164:
5165: FloppyDump(
5166: FLOPSHOW,
5167: ("Floppy: start drive - media is write protected\n")
5168: );
5169: return STATUS_MEDIA_WRITE_PROTECTED;
5170: }
5171: }
5172:
5173: return ntStatus;
5174: }
5175:
5176: NTSTATUS
5177: FlDatarateSpecifyConfigure(
5178: IN PDISKETTE_EXTENSION DisketteExtension
5179: )
5180:
5181: /*++
5182:
5183: Routine Description:
5184:
5185: This routine is called to set up the controller every time a new type
5186: of diskette is to be accessed. It issues the CONFIGURE command if
5187: it's available, does a SPECIFY, sets the data rate, and RECALIBRATEs
5188: the drive.
5189:
5190: The caller must set DisketteExtension->DriveMediaType before calling
5191: this routine.
5192:
5193: Arguments:
5194:
5195: DisketteExtension - pointer to our data area for the drive to be
5196: prepared.
5197:
5198: Return Value:
5199:
5200: STATUS_SUCCESS if the controller is properly prepared; appropriate
5201: error propogated otherwise.
5202:
5203: --*/
5204:
5205: {
5206: PCONTROLLER_DATA controllerData;
5207: NTSTATUS ntStatus = STATUS_SUCCESS;
5208:
5209: FloppyDump(
5210: FLOPSHOW,
5211: ("Floppy: FloppyDatarateSpecifyConfigure...\n")
5212: );
5213:
5214: controllerData = DisketteExtension->ControllerData;
5215:
5216: //
5217: // If the controller has a CONFIGURE command, use it to enable implied
5218: // seeks. If it doesn't, we'll find out here the first time through.
5219: //
5220:
5221: if ( controllerData->ControllerConfigurable ) {
5222:
5223: controllerData->FifoBuffer[0] = 0;
5224: controllerData->FifoBuffer[1] = COMMND_CONFIGURE_FIFO_THRESHOLD +
5225: COMMND_CONFIGURE_DISABLE_POLLING;
5226:
5227: if (!DisketteExtension->DriveMediaConstants.CylinderShift) {
5228:
5229: controllerData->FifoBuffer[1] += COMMND_CONFIGURE_IMPLIED_SEEKS;
5230:
5231: }
5232:
5233: controllerData->FifoBuffer[2] = 0;
5234:
5235: ntStatus = FlIssueCommand( COMMND_CONFIGURE, DisketteExtension );
5236:
5237: if ( ntStatus == STATUS_DEVICE_NOT_READY ) {
5238:
5239: //
5240: // Note the CONFIGURE command doesn't exist. Set status to
5241: // success, so we can issue the SPECIFY command below.
5242: //
5243:
5244: FloppyDump(
5245: FLOPINFO,
5246: ("Floppy: Ignore above error - no CONFIGURE command\n")
5247: );
5248:
5249: controllerData->ControllerConfigurable = FALSE;
5250:
5251: ntStatus = STATUS_SUCCESS;
5252: }
5253: }
5254:
5255: //
5256: // Issue SPECIFY command to program the head load and unload
5257: // rates, the drive step rate, and the DMA data transfer mode.
5258: //
5259:
5260: if ( NT_SUCCESS( ntStatus ) ) {
5261:
5262: controllerData->FifoBuffer[0] =
5263: DisketteExtension->DriveMediaConstants.StepRateHeadUnloadTime;
5264:
5265: controllerData->FifoBuffer[1] =
5266: DisketteExtension->DriveMediaConstants.HeadLoadTime;
5267:
5268: ntStatus = FlIssueCommand( COMMND_SPECIFY, DisketteExtension );
5269:
5270: if ( NT_SUCCESS( ntStatus ) ) {
5271:
5272: //
5273: // Program the data rate
5274: //
5275:
5276: WRITE_CONTROLLER(
5277: &controllerData->ControllerAddress->DRDC.DataRate,
5278: DisketteExtension->DriveMediaConstants.DataTransferRate );
5279:
5280: //
5281: // Recalibrate the drive, now that we've changed all its
5282: // parameters.
5283: //
5284:
5285: ntStatus = FlRecalibrateDrive( DisketteExtension );
5286: }
5287: }
5288:
5289: if ( NT_SUCCESS( ntStatus ) ) {
5290:
5291: controllerData->LastDriveMediaType = DisketteExtension->DriveMediaType;
5292:
5293: } else {
5294:
5295: controllerData->LastDriveMediaType = Unknown;
5296: }
5297:
5298: return ntStatus;
5299: }
5300:
5301: NTSTATUS
5302: FlRecalibrateDrive(
5303: IN PDISKETTE_EXTENSION DisketteExtension
5304: )
5305:
5306: /*++
5307:
5308: Routine Description:
5309:
5310: This routine recalibrates a drive. It is called whenever we're
5311: setting up to access a new diskette, and after certain errors. It
5312: will actually recalibrate twice, since many controllers stop after
5313: 77 steps and many disks have 80 tracks.
5314:
5315: Arguments:
5316:
5317: DisketteExtension - pointer to our data area for the drive to be
5318: recalibrated.
5319:
5320: Return Value:
5321:
5322: STATUS_SUCCESS if the drive is successfully recalibrated; appropriate
5323: error is propogated otherwise.
5324:
5325: --*/
5326:
5327: {
5328: PCONTROLLER_DATA controllerData;
5329: NTSTATUS ntStatus;
5330: UCHAR recalibrateCount;
5331:
5332: FloppyDump(
5333: FLOPSHOW,
5334: ("Floppy: FloppyRecalibrateDrive...\n")
5335: );
5336:
5337: controllerData = DisketteExtension->ControllerData;
5338:
5339: recalibrateCount = 0;
5340:
5341: do {
5342:
5343: //
5344: // Issue the recalibrate command
5345: //
5346:
5347: controllerData->FifoBuffer[0] = DisketteExtension->DeviceUnit;
5348:
5349: ntStatus = FlIssueCommand( COMMND_RECALIBRATE, DisketteExtension );
5350:
5351: if ( !NT_SUCCESS( ntStatus ) ) {
5352:
5353: FloppyDump(
5354: FLOPWARN,
5355: ("Floppy: recalibrate returned %x\n", ntStatus)
5356: );
5357:
5358: }
5359:
5360: if ( NT_SUCCESS( ntStatus ) ) {
5361:
5362: if ( !( controllerData->FifoBuffer[0] & STREG0_SEEK_COMPLETE ) ||
5363: ( controllerData->FifoBuffer[1] != 0 ) ) {
5364:
5365: FloppyDump(
5366: FLOPWARN,
5367: ("Floppy: recalibrate had bad registers\n")
5368: );
5369:
5370: controllerData->HardwareFailed = TRUE;
5371:
5372: ntStatus = STATUS_FLOPPY_BAD_REGISTERS;
5373: }
5374: }
5375:
5376: recalibrateCount++;
5377:
5378: } while ( ( !NT_SUCCESS( ntStatus ) ) && ( recalibrateCount < 2 ) );
5379:
5380: return ntStatus;
5381: }
5382:
5383: NTSTATUS
5384: FlDetermineMediaType(
5385: IN OUT PDISKETTE_EXTENSION DisketteExtension
5386: )
5387:
5388: /*++
5389:
5390: Routine Description:
5391:
5392: This routine is called by FlStartDrive() when the media type is
5393: unknown. It assumes the largest media supported by the drive is
5394: available, and keeps trying lower values until it finds one that
5395: works.
5396:
5397: Arguments:
5398:
5399: DisketteExtension - pointer to our data area for the drive whose
5400: media is to checked.
5401:
5402: Return Value:
5403:
5404: STATUS_SUCCESS if the type of the media is determined; appropriate
5405: error propogated otherwise.
5406:
5407: --*/
5408:
5409: {
5410: NTSTATUS ntStatus;
5411: PCONTROLLER_DATA controllerData;
5412: PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
5413: BOOLEAN mediaTypesExhausted = FALSE;
5414: ULONG retries = 0;
5415:
5416: FloppyDump(
5417: FLOPSHOW,
5418: ("Floppy: FloppyDetermineMediaType...\n")
5419: );
5420:
5421: controllerData = DisketteExtension->ControllerData;
5422:
5423: //
5424: // Try up to three times for read the media id.
5425: //
5426:
5427: for (
5428: retries = 0;
5429: retries < 3;
5430: retries++
5431: ) {
5432:
5433: if (retries) {
5434:
5435: //
5436: // We're retrying the media determination because
5437: // some silly controllers don't always want to work
5438: // at setup. First we'll reset the device to give
5439: // it a better chance of working.
5440: //
5441:
5442: FlInitializeControllerHardware(
5443: controllerData,
5444: DisketteExtension->DeviceObject
5445: );
5446:
5447: }
5448:
5449: //
5450: // Assume that the largest supported media is in the drive. If that
5451: // turns out to be untrue, we'll try successively smaller media types
5452: // until we find what's really in there (or we run out and decide
5453: // that the media isn't formatted).
5454: //
5455:
5456: DisketteExtension->DriveMediaType =
5457: DriveMediaLimits[DisketteExtension->DriveType].HighestDriveMediaType;
5458: DisketteExtension->DriveMediaConstants =
5459: DriveMediaConstants[DisketteExtension->DriveMediaType];
5460:
5461: do {
5462:
5463: ntStatus = FlDatarateSpecifyConfigure( DisketteExtension );
5464:
5465: if ( !NT_SUCCESS( ntStatus ) ) {
5466:
5467: //
5468: // The SPECIFY or CONFIGURE commands resulted in an error.
5469: // Force ourselves out of this loop and return error.
5470: //
5471:
5472: mediaTypesExhausted = TRUE;
5473:
5474: } else {
5475:
5476: //
5477: // Use the media constants table when trying to determine
5478: // media type.
5479: //
5480:
5481: driveMediaConstants =
5482: &DriveMediaConstants[DisketteExtension->DriveMediaType];
5483:
5484: //
5485: // Now try to read the ID from wherever we're at.
5486: //
5487:
5488: controllerData->FifoBuffer[0] = (UCHAR)
5489: ( DisketteExtension->DeviceUnit |
5490: ( ( driveMediaConstants->NumberOfHeads - 1 ) << 2 ) );
5491:
5492: ntStatus = FlIssueCommand(
5493: COMMND_READ_ID + COMMND_MFM,
5494: DisketteExtension );
5495:
5496: if ( ( !NT_SUCCESS( ntStatus ) ) ||
5497: ( controllerData->FifoBuffer[0] !=
5498: (UCHAR)( ( DisketteExtension->DeviceUnit ) |
5499: ( ( driveMediaConstants->NumberOfHeads - 1 ) << 2 ) ) ) ||
5500: ( controllerData->FifoBuffer[1] != 0 ) ||
5501: ( controllerData->FifoBuffer[2] != 0 ) ) {
5502:
5503: FloppyDump(
5504: FLOPINFO,
5505: ("Floppy: READID failed trying lower media\n"
5506: "------ status = %x\n"
5507: "------ SR0 = %x\n"
5508: "------ SR1 = %x\n"
5509: "------ SR2 = %x\n",
5510: ntStatus,
5511: controllerData->FifoBuffer[0],
5512: controllerData->FifoBuffer[1],
5513: controllerData->FifoBuffer[2])
5514: );
5515:
5516: DisketteExtension->DriveMediaType--;
5517: DisketteExtension->DriveMediaConstants =
5518: DriveMediaConstants[DisketteExtension->DriveMediaType];
5519:
5520: if (ntStatus != STATUS_DEVICE_NOT_READY) {
5521:
5522: ntStatus = STATUS_UNRECOGNIZED_MEDIA;
5523:
5524: }
5525:
5526: //
5527: // Next comparison must be signed, for when
5528: // LowestDriveMediaType = 0.
5529: //
5530:
5531: if ( (CHAR)( DisketteExtension->DriveMediaType ) <
5532: (CHAR)( DriveMediaLimits[DisketteExtension->DriveType].
5533: LowestDriveMediaType ) ) {
5534:
5535: DisketteExtension->MediaType = Unknown;
5536: mediaTypesExhausted = TRUE;
5537:
5538: FloppyDump(
5539: FLOPINFO,
5540: ("Floppy: Unrecognized media.\n")
5541: );
5542:
5543: }
5544:
5545: }
5546:
5547: }
5548:
5549: } while ( ( !NT_SUCCESS( ntStatus ) ) && !( mediaTypesExhausted ) );
5550:
5551: if (NT_SUCCESS(ntStatus)) {
5552:
5553: //
5554: // We determined the media type. Time to move on.
5555: //
5556:
5557: break;
5558:
5559: }
5560:
5561: }
5562:
5563: if ( (!NT_SUCCESS( ntStatus )) || mediaTypesExhausted) {
5564:
5565: return ntStatus;
5566:
5567: }
5568:
5569: DisketteExtension->MediaType = driveMediaConstants->MediaType;
5570:
5571: DisketteExtension->BytesPerSector =
5572: driveMediaConstants->BytesPerSector;
5573:
5574: FloppyDump(
5575: FLOPINFO,
5576: ("Floppy: MediaType is %x\n", DisketteExtension->MediaType)
5577: );
5578:
5579: DisketteExtension->ByteCapacity =
5580: ( driveMediaConstants->BytesPerSector ) *
5581: driveMediaConstants->SectorsPerTrack *
5582: ( 1 + driveMediaConstants->MaximumTrack ) *
5583: driveMediaConstants->NumberOfHeads;
5584:
5585: //
5586: // Structure copy the media constants into the diskette extension.
5587: //
5588:
5589: DisketteExtension->DriveMediaConstants =
5590: DriveMediaConstants[DisketteExtension->DriveMediaType];
5591:
5592: return ntStatus;
5593: }
5594:
5595: VOID
5596: FloppyThread(
5597: PVOID Context
5598: )
5599:
5600: /*++
5601:
5602: Routine Description:
5603:
5604: This is the code executed by the system thread created when the
5605: floppy driver initializes. This thread loops forever (or until a
5606: flag is set telling the thread to kill itself) processing packets
5607: put into the queue by the dispatch routines.
5608:
5609: For each packet, this thread calls appropriate routines to process
5610: the request, and then calls FlFinishOperation() to complete the
5611: packet.
5612:
5613: Arguments:
5614:
5615: Context - a pointer to our data area for the controller being
5616: supported (there is one thread per controller).
5617:
5618: Return Value:
5619:
5620: None.
5621:
5622: --*/
5623:
5624: {
5625: PCONTROLLER_DATA controllerData = Context;
5626: PIRP irp;
5627: PIO_STACK_LOCATION irpSp;
5628: PLIST_ENTRY request;
5629: PDISKETTE_EXTENSION disketteExtension;
5630: KIRQL oldIrql;
5631: NTSTATUS ntStatus;
5632: NTSTATUS waitStatus;
5633: LARGE_INTEGER controllerWait;
5634:
5635: //
5636: // Set thread priority to lowest realtime level.
5637: //
5638:
5639: KeSetPriorityThread(KeGetCurrentThread(), LOW_REALTIME_PRIORITY);
5640:
5641: controllerWait = RtlLargeIntegerNegate(
5642: RtlConvertLongToLargeInteger(
5643: (LONG)(10 * 1000 * 3000)
5644: )
5645: );
5646:
5647: do {
5648:
5649: //
5650: // Wait for a request from the dispatch routines.
5651: // KeWaitForSingleObject won't return error here - this thread
5652: // isn't alertable and won't take APCs, and we're not passing in
5653: // a timeout.
5654: //
5655:
5656: KeWaitForSingleObject(
5657: (PVOID) &controllerData->RequestSemaphore,
5658: UserRequest,
5659: KernelMode,
5660: FALSE,
5661: (PLARGE_INTEGER) NULL );
5662:
5663: if ( controllerData->UnloadingDriver ) {
5664:
5665: FloppyDump(
5666: FLOPDBGP,
5667: ("Floppy: Thread asked to kill itself\n")
5668: );
5669:
5670: PsTerminateSystemThread( STATUS_SUCCESS );
5671: }
5672:
5673: waitStatus = STATUS_SUCCESS;
5674:
5675: waitStatus = KeWaitForSingleObject(
5676: controllerData->ControllerEvent,
5677: Executive,
5678: KernelMode,
5679: FALSE,
5680: &controllerWait);
5681:
5682:
5683: if (waitStatus == STATUS_TIMEOUT) {
5684:
5685: while ( !IsListEmpty( &( controllerData->ListEntry ) ) ) {
5686:
5687: //
5688: // Get the request from the queue. We know there is one,
5689: // because of the check above.
5690: //
5691:
5692: request = ExInterlockedRemoveHeadList(
5693: &controllerData->ListEntry,
5694: &controllerData->ListSpinLock );
5695:
5696: controllerData->HardwareFailed = FALSE;
5697:
5698: irp = CONTAINING_RECORD( request, IRP, Tail.Overlay.ListEntry );
5699:
5700: irp->IoStatus.Status = STATUS_DEVICE_BUSY;
5701:
5702: IoCompleteRequest( irp, IO_DISK_INCREMENT );
5703:
5704: } //while there's packets to process
5705:
5706: } else {
5707:
5708: controllerData->CurrentInterrupt = TRUE;
5709:
5710: while ( !IsListEmpty( &( controllerData->ListEntry ) ) ) {
5711:
5712: //
5713: // Get the request from the queue. We know there is one,
5714: // because of the check above.
5715: //
5716:
5717: request = ExInterlockedRemoveHeadList(
5718: &controllerData->ListEntry,
5719: &controllerData->ListSpinLock );
5720:
5721: controllerData->HardwareFailed = FALSE;
5722:
5723: irp = CONTAINING_RECORD( request, IRP, Tail.Overlay.ListEntry );
5724:
5725:
5726: irpSp = IoGetCurrentIrpStackLocation( irp );
5727:
5728: FloppyDump(
5729: FLOPIRPPATH,
5730: ("Floppy: Starting up IRP: %x for extension %x\n",
5731: irp,irpSp->Parameters.Read.Key)
5732: );
5733: switch ( irpSp->MajorFunction ) {
5734:
5735: case IRP_MJ_READ:
5736: case IRP_MJ_WRITE: {
5737:
5738: //
5739: // Get the diskette extension from where it was hidden
5740: // in the IRP.
5741: //
5742:
5743: disketteExtension = (PDISKETTE_EXTENSION)
5744: irpSp->Parameters.Read.Key;
5745:
5746: //
5747: // Until the file system clears the DO_VERIFY_VOLUME
5748: // flag, we should return all requests with error.
5749: //
5750:
5751: if (( disketteExtension->DeviceObject->Flags &
5752: DO_VERIFY_VOLUME ) &&
5753: !(irpSp->Flags & SL_OVERRIDE_VERIFY_VOLUME))
5754: {
5755:
5756: FloppyDump(
5757: FLOPINFO,
5758: ("Floppy: clearing queue; verify required\n")
5759: );
5760:
5761: //
5762: // The disk changed, and we set this bit. Fail
5763: // all current IRPs for this device; when all are
5764: // returned, the file system will clear
5765: // DO_VERIFY_VOLUME.
5766: //
5767:
5768: ntStatus = STATUS_VERIFY_REQUIRED;
5769:
5770: } else {
5771:
5772: //
5773: // Allocate an adapter channel for the I/O.
5774: //
5775:
5776: FloppyDump(
5777: FLOPIRPPATH,
5778: ("Floppy: About to allocate adapter channel %x\n",
5779: controllerData->AdapterObject)
5780: );
5781: KeResetEvent(
5782: &controllerData->AllocateAdapterChannelEvent );
5783:
5784: KeRaiseIrql( DISPATCH_LEVEL, &oldIrql );
5785:
5786: IoAllocateAdapterChannel(
5787: controllerData->AdapterObject,
5788: disketteExtension->DeviceObject,
5789: controllerData->NumberOfMapRegisters,
5790: FloppyAllocateAdapterChannel,
5791: controllerData );
5792:
5793: KeLowerIrql( oldIrql );
5794:
5795: //
5796: // Wait for the adapter to be allocated. No
5797: // timeout; we trust the system to do it
5798: // properly - so KeWaitForSingleObject can't
5799: // return an error.
5800: //
5801:
5802: KeWaitForSingleObject(
5803: &controllerData->AllocateAdapterChannelEvent,
5804: Executive,
5805: KernelMode,
5806: FALSE,
5807: (PLARGE_INTEGER) NULL );
5808:
5809: FloppyDump(
5810: FLOPIRPPATH,
5811: ("Floppy: Allocated adapter channel %x\n",
5812: controllerData->AdapterObject)
5813: );
5814: ntStatus = FlReadWrite( disketteExtension, irp );
5815:
5816: //
5817: // Free the adapter channel that we just used.
5818: //
5819:
5820: KeRaiseIrql( DISPATCH_LEVEL, &oldIrql );
5821:
5822: IoFreeAdapterChannel( controllerData->AdapterObject );
5823:
5824: KeLowerIrql( oldIrql );
5825: }
5826:
5827: break;
5828: }
5829:
5830: case IRP_MJ_DEVICE_CONTROL: {
5831:
5832: disketteExtension = (PDISKETTE_EXTENSION)
5833: irpSp->Parameters.DeviceIoControl.Type3InputBuffer;
5834:
5835: //
5836: // Until the file system clears the DO_VERIFY_VOLUME
5837: // flag, we should return all requests with error.
5838: //
5839:
5840: if (( disketteExtension->DeviceObject->Flags &
5841: DO_VERIFY_VOLUME ) &&
5842: !(irpSp->Flags & SL_OVERRIDE_VERIFY_VOLUME))
5843: {
5844:
5845: FloppyDump(
5846: FLOPINFO,
5847: ("Floppy: clearing queue; verify required\n")
5848: );
5849:
5850: //
5851: // The disk changed, and we set this bit. Fail
5852: // all current IRPs; when all are returned, the
5853: // file system will clear DO_VERIFY_VOLUME.
5854: //
5855:
5856: ntStatus = STATUS_VERIFY_REQUIRED;
5857:
5858: } else {
5859:
5860: switch (
5861: irpSp->Parameters.DeviceIoControl.IoControlCode ) {
5862:
5863: case IOCTL_DISK_CHECK_VERIFY: {
5864:
5865: //
5866: // Just start the drive; it will
5867: // automatically check whether or not the
5868: // disk has been changed.
5869: //
5870:
5871: FloppyDump(
5872: FLOPSHOW,
5873: ("Floppy: IOCTL_DISK_CHECK_VERIFY called\n")
5874: );
5875:
5876: ntStatus = FlStartDrive(
5877: disketteExtension,
5878: FALSE,
5879: FALSE,
5880: FALSE);
5881:
5882: break;
5883: }
5884:
5885: case IOCTL_DISK_GET_DRIVE_GEOMETRY: {
5886:
5887: FloppyDump(
5888: FLOPSHOW,
5889: ("Floppy: IOCTL_DISK_GET_DRIVE_GEOMETRY\n")
5890: );
5891:
5892: //
5893: // If there's enough room to write the
5894: // data, start the drive to make sure we
5895: // know what type of media is in the drive.
5896: //
5897:
5898: if ( irpSp->Parameters.DeviceIoControl.
5899: OutputBufferLength <
5900: sizeof( DISK_GEOMETRY ) ) {
5901:
5902: ntStatus = STATUS_INVALID_PARAMETER;
5903:
5904: } else {
5905:
5906: ntStatus = FlStartDrive(
5907: disketteExtension,
5908: FALSE,
5909: TRUE,
5910: (BOOLEAN)!!(irpSp->Flags &
5911: SL_OVERRIDE_VERIFY_VOLUME));
5912: }
5913:
5914: //
5915: // If the media wasn't formatted, FlStartDrive
5916: // returned STATUS_UNRECOGNIZED_MEDIA.
5917: //
5918:
5919: if ( NT_SUCCESS( ntStatus ) ||
5920: ( ntStatus == STATUS_UNRECOGNIZED_MEDIA ) ) {
5921:
5922: PDISK_GEOMETRY outputBuffer =
5923: (PDISK_GEOMETRY)
5924: irp->AssociatedIrp.SystemBuffer;
5925:
5926: //
5927: // Always return the media type, even if
5928: // it's unknown.
5929: //
5930:
5931: ntStatus = STATUS_SUCCESS;
5932:
5933: outputBuffer->MediaType =
5934: disketteExtension->MediaType;
5935:
5936: //
5937: // The rest of the fields only have meaning
5938: // if the media type is known.
5939: //
5940:
5941: if ( disketteExtension->MediaType ==
5942: Unknown ) {
5943:
5944: FloppyDump(
5945: FLOPSHOW,
5946: ("Floppy: geometry unknown\n")
5947: );
5948:
5949: //
5950: // Just zero out everything. The
5951: // caller shouldn't look at it.
5952: //
5953:
5954: outputBuffer->Cylinders.LowPart = 0;
5955: outputBuffer->Cylinders.HighPart = 0;
5956: outputBuffer->TracksPerCylinder = 0;
5957: outputBuffer->SectorsPerTrack = 0;
5958: outputBuffer->BytesPerSector = 0;
5959:
5960: } else {
5961:
5962: //
5963: // Return the geometry of the current
5964: // media.
5965: //
5966:
5967: FloppyDump(
5968: FLOPSHOW,
5969: ("Floppy: geomentry is known\n")
5970: );
5971: outputBuffer->Cylinders.LowPart =
5972: disketteExtension->DriveMediaConstants.MaximumTrack + 1;
5973:
5974: outputBuffer->Cylinders.HighPart = 0;
5975:
5976: outputBuffer->TracksPerCylinder =
5977: disketteExtension->DriveMediaConstants.NumberOfHeads;
5978:
5979: outputBuffer->SectorsPerTrack =
5980: disketteExtension->DriveMediaConstants.SectorsPerTrack;
5981:
5982: outputBuffer->BytesPerSector =
5983: disketteExtension->DriveMediaConstants.BytesPerSector;
5984: }
5985:
5986: FloppyDump(
5987: FLOPSHOW,
5988: ("Floppy: Geometry\n"
5989: "------- Cylinders low: 0x%x\n"
5990: "------- Cylinders high: 0x%x\n"
5991: "------- Track/Cyl: 0x%x\n"
5992: "------- Sectors/Track: 0x%x\n"
5993: "------- Bytes/Sector: 0x%x\n"
5994: "------- Media Type: %d\n",
5995: outputBuffer->Cylinders.LowPart,
5996: outputBuffer->Cylinders.HighPart,
5997: outputBuffer->TracksPerCylinder,
5998: outputBuffer->SectorsPerTrack,
5999: outputBuffer->BytesPerSector,
6000: outputBuffer->MediaType)
6001: );
6002:
6003: }
6004:
6005: irp->IoStatus.Information =
6006: sizeof( DISK_GEOMETRY );
6007:
6008: break;
6009: }
6010:
6011: case IOCTL_DISK_FORMAT_TRACKS: {
6012:
6013: FloppyDump(
6014: FLOPSHOW,
6015: ("Floppy: IOCTL_DISK_FORMAT_TRACKS\n")
6016: );
6017:
6018: //
6019: // Start the drive, and make sure it's not
6020: // write protected.
6021: //
6022:
6023: ntStatus = FlStartDrive(
6024: disketteExtension,
6025: TRUE,
6026: FALSE,
6027: FALSE );
6028:
6029: //
6030: // Note that FlStartDrive could have returned
6031: // STATUS_UNRECOGNIZED_MEDIA if the drive
6032: // wasn't formatted.
6033: //
6034:
6035: if ( NT_SUCCESS( ntStatus ) ||
6036: ( ntStatus == STATUS_UNRECOGNIZED_MEDIA ) ) {
6037:
6038: //
6039: // Allocate an adapter channel to do
6040: // the format.
6041: //
6042:
6043: KeResetEvent( &controllerData->
6044: AllocateAdapterChannelEvent );
6045:
6046: KeRaiseIrql( DISPATCH_LEVEL, &oldIrql );
6047:
6048: IoAllocateAdapterChannel(
6049: controllerData->AdapterObject,
6050: disketteExtension->DeviceObject,
6051: controllerData->NumberOfMapRegisters,
6052: FloppyAllocateAdapterChannel,
6053: controllerData );
6054:
6055: KeLowerIrql( oldIrql );
6056:
6057: //
6058: // Wait for the adapter to be allocated.
6059: // No timeout; we trust the system to do
6060: // it properly - so KeWaitForSingleObject
6061: // can't return an error.
6062: //
6063:
6064: KeWaitForSingleObject(
6065: &controllerData->
6066: AllocateAdapterChannelEvent,
6067: Executive,
6068: KernelMode,
6069: FALSE,
6070: (PLARGE_INTEGER) NULL );
6071:
6072: ntStatus = FlFormat(
6073: disketteExtension,
6074: irp );
6075:
6076: //
6077: // Free the adapter channel.
6078: //
6079:
6080: KeRaiseIrql( DISPATCH_LEVEL, &oldIrql );
6081:
6082: IoFreeAdapterChannel(
6083: controllerData->AdapterObject );
6084:
6085: KeLowerIrql( oldIrql );
6086: }
6087:
6088: break;
6089: } //end of case format
6090: } //end of switch controlcode
6091: }
6092:
6093: break;
6094: } //end of case IOCTL
6095:
6096: default: {
6097:
6098: FloppyDump(
6099: FLOPDBGP,
6100: ("Floppy: bad majorfunction %x\n",irpSp->MajorFunction)
6101: );
6102: }
6103:
6104: } //end of switch on majorfunction
6105:
6106: //
6107: // All operations leave a final status in ntStatus. Copy it
6108: // to the IRP, and then complete the operation.
6109: //
6110:
6111: irp->IoStatus.Status = ntStatus;
6112:
6113: FlFinishOperation( irp, disketteExtension );
6114:
6115: } //while there's packets to process
6116:
6117: controllerData->CurrentInterrupt = FALSE;
6118:
6119: (VOID) KeSetEvent(
6120: controllerData->ControllerEvent,
6121: (KPRIORITY) 0,
6122: FALSE);
6123:
6124: }
6125:
6126: } while ( TRUE );
6127: }
6128:
6129: IO_ALLOCATION_ACTION
6130: FloppyAllocateAdapterChannel(
6131: IN PDEVICE_OBJECT DeviceObject,
6132: IN PIRP Irp,
6133: IN PVOID MapRegisterBase,
6134: IN PVOID Context
6135: )
6136:
6137: /*++
6138:
6139: Routine Description:
6140:
6141: This DPC is called whenever the floppy thread is trying to allocate
6142: the adapter channel (like before doing a read or write). It saves
6143: the MapRegisterBase in the controller data area, and sets the
6144: AllocateAdapterChannelEvent to awaken the thread.
6145:
6146: Arguments:
6147:
6148: DeviceObject - unused.
6149:
6150: Irp - unused.
6151:
6152: MapRegisterBase - the base of the map registers that can be used
6153: for this transfer.
6154:
6155: Context - a pointer to our controller data area.
6156:
6157: Return Value:
6158:
6159: Returns Allocation Action 'KeepObject' which means that the adapter
6160: object will be held for now (to be released explicitly later).
6161:
6162: --*/
6163: {
6164: PCONTROLLER_DATA controllerData = Context;
6165:
6166: UNREFERENCED_PARAMETER( DeviceObject );
6167: UNREFERENCED_PARAMETER( Irp );
6168:
6169: controllerData->MapRegisterBase = MapRegisterBase;
6170:
6171: KeSetEvent(
6172: &controllerData->AllocateAdapterChannelEvent,
6173: 0L,
6174: FALSE );
6175:
6176: return KeepObject;
6177: }
6178:
6179: NTSTATUS
6180: FlReadWrite(
6181: IN OUT PDISKETTE_EXTENSION DisketteExtension,
6182: IN OUT PIRP Irp
6183: )
6184:
6185: /*++
6186:
6187: Routine Description:
6188:
6189: This routine is called by the floppy thread to read/write data
6190: to/from the diskette. It breaks the request into pieces called
6191: "transfers" (their size depends on the buffer size, where the end of
6192: the track is, etc) and retries each transfer until it succeeds or
6193: the retry count is exceeded.
6194:
6195: Arguments:
6196:
6197: DisketteExtension - a pointer to our data area for the drive to be
6198: accessed.
6199:
6200: Irp - a pointer to the IO Request Packet.
6201:
6202: Return Value:
6203:
6204: STATUS_SUCCESS if the packet was successfully read or written; the
6205: appropriate error is propogated otherwise.
6206:
6207: --*/
6208:
6209: {
6210: LARGE_INTEGER headSettleTime;
6211: PIO_STACK_LOCATION irpSp;
6212: PCONTROLLER_DATA controllerData;
6213: PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
6214: PUCHAR userBuffer;
6215: NTSTATUS ntStatus;
6216: NTSTATUS ntStatus2;
6217: ULONG startingSectorOfTransfer;
6218: ULONG totalBytesOfTransfer;
6219: ULONG bytesTransferredSoFar = 0;
6220: ULONG numberOfPagesInTransfer;
6221: UCHAR transferCylinder;
6222: UCHAR transferSector;
6223: UCHAR transferHead;
6224: UCHAR byteToSectorShift;
6225: UCHAR retryCount;
6226: UCHAR secondaryRetryCount;
6227: UCHAR mediaDescriptor;
6228: DRIVE_MEDIA_TYPE driveMediaType;
6229: MEDIA_TYPE mediaType;
6230: BOOLEAN writeOperation;
6231: BOOLEAN fatalError;
6232: BOOLEAN needToUseBuffer;
6233: BOOLEAN fifoDisabled = FALSE;
6234:
6235: FloppyDump(
6236: FLOPSHOW,
6237: ("Floppy: FloppyReadWrite...\n")
6238: );
6239:
6240: FloppyDump(
6241: FLOPIRPPATH,
6242: ("Floppy: Started read/write for irp %x extension %x\n",
6243: Irp,DisketteExtension)
6244: );
6245: //
6246: // Get some useful pointers.
6247: //
6248:
6249: controllerData = DisketteExtension->ControllerData;
6250: irpSp = IoGetCurrentIrpStackLocation( Irp );
6251:
6252: if ( irpSp->MajorFunction == IRP_MJ_WRITE ) {
6253:
6254: writeOperation = TRUE;
6255:
6256: } else {
6257:
6258: writeOperation = FALSE;
6259: }
6260:
6261: //
6262: // If the drive is not already running, wait for it to start up. If
6263: // we're writing, this will check to see if the diskette is protected.
6264: //
6265:
6266: FloppyDump(
6267: FLOPIRPPATH,
6268: ("Floppy: Waiting for drive to start for irp %x extension %x\n",
6269: Irp,DisketteExtension)
6270: );
6271: ntStatus = FlStartDrive( DisketteExtension,
6272: writeOperation,
6273: TRUE,
6274: (BOOLEAN)!!(irpSp->Flags & SL_OVERRIDE_VERIFY_VOLUME));
6275: if ( !NT_SUCCESS( ntStatus ) ) {
6276:
6277: FloppyDump(
6278: FLOPIRPPATH,
6279: ("Floppy: Couldnt start drive for irp %x extension %x\n",
6280: Irp,DisketteExtension)
6281: );
6282: return ntStatus;
6283: }
6284:
6285: FloppyDump(
6286: FLOPIRPPATH,
6287: ("Floppy: Drive started for irp %x extension %x\n",
6288: Irp,DisketteExtension)
6289: );
6290:
6291: if ( DisketteExtension->MediaType == Unknown ) {
6292:
6293: FloppyDump(
6294: FLOPWARN,
6295: ("Floppy: read/write: media type not determined, failing\n")
6296: );
6297:
6298: FloppyDump(
6299: FLOPIRPPATH,
6300: ("Floppy: don't know media irp %x extension %x\n",
6301: Irp,DisketteExtension)
6302: );
6303: return STATUS_UNRECOGNIZED_MEDIA;
6304:
6305: }
6306:
6307: //
6308: // Must get this pointer AFTER FlStartDrive, since DriveMediaType may
6309: // have been newly determined there.
6310: //
6311:
6312: driveMediaConstants = &DisketteExtension->DriveMediaConstants;
6313:
6314: //
6315: // Initialize variables to be used in the loop that transfers
6316: // portions of the request.
6317: //
6318:
6319: byteToSectorShift = (UCHAR)( SECTORLENGTHCODE_TO_BYTESHIFT +
6320: driveMediaConstants->SectorLengthCode );
6321:
6322: fatalError = FALSE;
6323:
6324: userBuffer = (PUCHAR) MmGetSystemAddressForMdl( Irp->MdlAddress );
6325:
6326: FloppyDump(
6327: FLOPSHOW,
6328: ("Floppy: Length of I/O is : %x\n"
6329: "------ userBuffer is : %lx\n",
6330: irpSp->Parameters.Read.Length,
6331: userBuffer)
6332: );
6333:
6334: //
6335: // Transfer portions of the request until the request is done or failed
6336: //
6337:
6338: while ( ( bytesTransferredSoFar < irpSp->Parameters.Read.Length ) &&
6339: !( fatalError ) ) {
6340:
6341: //
6342: // Determine the initial sector to be read from the diskette.
6343: //
6344:
6345: startingSectorOfTransfer =
6346: ( ( irpSp->Parameters.Read.ByteOffset ).LowPart +
6347: bytesTransferredSoFar ) >> byteToSectorShift;
6348:
6349: transferCylinder = (UCHAR)( startingSectorOfTransfer /
6350: ( driveMediaConstants->SectorsPerTrack *
6351: driveMediaConstants->NumberOfHeads ) );
6352:
6353: transferSector = (UCHAR)( ( startingSectorOfTransfer %
6354: driveMediaConstants->SectorsPerTrack ) + 1 );
6355:
6356: transferHead = (UCHAR)( ( startingSectorOfTransfer /
6357: driveMediaConstants->SectorsPerTrack ) %
6358: driveMediaConstants->NumberOfHeads );
6359:
6360: totalBytesOfTransfer = irpSp->Parameters.Read.Length -
6361: bytesTransferredSoFar;
6362:
6363: FloppyDump(
6364: FLOPSHOW,
6365: ("Floppy: SectorsPerTrack = %x\n"
6366: "------ NumberOfHeads = %x\n"
6367: "------ startingSectorOfTransfer = %x\n"
6368: "------ transferCylinder = %x\n"
6369: "------ transferSector = %x\n"
6370: "------ transferHead = %x\n",
6371: driveMediaConstants->SectorsPerTrack,
6372: driveMediaConstants->NumberOfHeads,
6373: startingSectorOfTransfer,
6374: transferCylinder,
6375: transferSector,
6376: transferHead)
6377: );
6378:
6379: //
6380: // Make sure the transfer doesn't go past the end of the track
6381: //
6382:
6383: if ( ( totalBytesOfTransfer >> byteToSectorShift ) > (ULONG)
6384: ( driveMediaConstants->SectorsPerTrack - transferSector + 1 ) ) {
6385:
6386: totalBytesOfTransfer = ( driveMediaConstants->SectorsPerTrack -
6387: transferSector + 1 ) << byteToSectorShift;
6388: }
6389:
6390: //
6391: // If there aren't enough map registers to handle the whole
6392: // transfer, then make the transfer size equal to the size of the
6393: // contiguous buffer.
6394: //
6395:
6396: numberOfPagesInTransfer = ADDRESS_AND_SIZE_TO_SPAN_PAGES(
6397: ( userBuffer + bytesTransferredSoFar ),
6398: totalBytesOfTransfer );
6399:
6400: if ( numberOfPagesInTransfer <=
6401: (ULONG) controllerData->NumberOfMapRegisters ) {
6402:
6403: needToUseBuffer = FALSE;
6404:
6405: } else {
6406:
6407: FloppyDump(
6408: FLOPSHOW,
6409: ("Floppy: Not enough map registers, using own buffer\n")
6410: );
6411:
6412: needToUseBuffer = TRUE;
6413:
6414: #ifdef KEEP_COUNTERS
6415: FloppyUsedBuffer++;
6416: #endif
6417: if ( totalBytesOfTransfer > controllerData->IoBufferSize ) {
6418:
6419: totalBytesOfTransfer = controllerData->IoBufferSize;
6420: }
6421: }
6422:
6423: FloppyDump(
6424: FLOPSHOW,
6425: ("Floppy: TransferLength = %lx\n", totalBytesOfTransfer)
6426: );
6427:
6428: //
6429: // If this is a write and we have to use the contiguous buffer
6430: // (because we don't have enough map registers) then copy the
6431: // data from the user's buffer to the contiguous buffer.
6432: //
6433:
6434: if ( ( needToUseBuffer ) &&
6435: ( writeOperation ) ) {
6436:
6437: FloppyDump(
6438: FLOPSHOW,
6439: ("Floppy: Writing from address %lx\n",
6440: userBuffer + bytesTransferredSoFar)
6441: );
6442:
6443: RtlMoveMemory(
6444: controllerData->IoBuffer,
6445: (PVOID)( userBuffer + bytesTransferredSoFar ),
6446: totalBytesOfTransfer );
6447: }
6448:
6449: retryCount = 0;
6450: secondaryRetryCount = 0;
6451:
6452: //
6453: // Try this transfer until it succeeds or is failed.
6454: //
6455:
6456: do {
6457:
6458: //
6459: // If the controller doesn't do an implicit seek, then do an
6460: // explicit one.
6461: //
6462: // Also do an explicit seek if this drive isn't set up to
6463: // seek properly on this media, as noted by CylinderShift.
6464: // (This happens for 360kb diskettes in 1.2Mb drives).
6465: //
6466:
6467: if ( ( !controllerData->ControllerConfigurable ) ||
6468: ( driveMediaConstants->CylinderShift != 0 ) ) {
6469:
6470: controllerData->FifoBuffer[0] = (UCHAR)
6471: ( ( transferHead << 2 ) | DisketteExtension->DeviceUnit );
6472: controllerData->FifoBuffer[1] = (UCHAR)( transferCylinder <<
6473: driveMediaConstants->CylinderShift );
6474:
6475: FloppyDump(
6476: FLOPSHOW,
6477: ("Floppy: Issuing SEEK to %x\n",
6478: controllerData->FifoBuffer[1])
6479: );
6480:
6481: #ifdef KEEP_COUNTERS
6482: FloppyUsedSeek++;
6483: #endif
6484:
6485: ntStatus = FlIssueCommand( COMMND_SEEK, DisketteExtension );
6486:
6487: if ( !NT_SUCCESS( ntStatus ) ) {
6488:
6489: FloppyDump(
6490: FLOPWARN,
6491: ("Floppy: SEEK returned %x\n", ntStatus)
6492: );
6493: }
6494:
6495: if ( NT_SUCCESS( ntStatus ) ) {
6496:
6497: FloppyDump(
6498: FLOPSHOW,
6499: ("Floppy: SEEK says we got to cylinder %x\n",
6500: controllerData->FifoBuffer[1])
6501: );
6502:
6503: if ( ( !( controllerData->FifoBuffer[0] &
6504: STREG0_SEEK_COMPLETE ) ||
6505: ( controllerData->FifoBuffer[1] != (UCHAR)
6506: ( transferCylinder <<
6507: driveMediaConstants->CylinderShift ) ) ) ) {
6508:
6509: FloppyDump(
6510: FLOPWARN,
6511: ("Floppy: Seek returned bad registers\n")
6512: );
6513:
6514: controllerData->HardwareFailed = TRUE;
6515:
6516: ntStatus = STATUS_FLOPPY_BAD_REGISTERS;
6517:
6518: } else {
6519:
6520: //
6521: // Must delay HeadSettleTime milliseconds before
6522: // doing anything after a SEEK.
6523: //
6524:
6525: headSettleTime.LowPart = - ( 10 * 1000 *
6526: driveMediaConstants->HeadSettleTime );
6527: headSettleTime.HighPart = -1;
6528:
6529: KeDelayExecutionThread(
6530: KernelMode,
6531: FALSE,
6532: &headSettleTime );
6533:
6534: //
6535: // SEEKs should always be followed by a READID.
6536: //
6537:
6538: controllerData->FifoBuffer[0] = (UCHAR)
6539: ( ( transferHead << 2 ) |
6540: DisketteExtension->DeviceUnit );
6541:
6542: ntStatus = FlIssueCommand(
6543: COMMND_READ_ID + COMMND_MFM,
6544: DisketteExtension );
6545:
6546: if ( !NT_SUCCESS( ntStatus ) ) {
6547:
6548: FloppyDump(
6549: FLOPWARN,
6550: ("Floppy: READID after seek returned %x\n",
6551: ntStatus)
6552: );
6553: }
6554:
6555: if ( NT_SUCCESS( ntStatus ) ) {
6556:
6557: FloppyDump(
6558: FLOPSHOW,
6559: ("Floppy: ReadID says we're on cylinder %x\n",
6560: controllerData->FifoBuffer[3])
6561: );
6562:
6563: if ( ( controllerData->FifoBuffer[0] != (UCHAR)
6564: ( ( transferHead << 2 ) |
6565: DisketteExtension->DeviceUnit ) ) ||
6566: ( controllerData->FifoBuffer[1] != 0 ) ||
6567: ( controllerData->FifoBuffer[2] != 0 ) ||
6568: ( controllerData->FifoBuffer[3] !=
6569: transferCylinder ) ) {
6570:
6571: FloppyDump(
6572: FLOPWARN,
6573: ("Floppy: READID returned bad registers\n"
6574: "------ StatusRegister0 = %x\n"
6575: "------ StatusRegister1 = %x\n"
6576: "------ StatusRegister2 = %x\n"
6577: "------ StatusRegister3 = %x\n"
6578: "------ actualCylinder = %x\n"
6579: "------ transferCylinder = %x\n",
6580: controllerData->FifoBuffer[0],
6581: controllerData->FifoBuffer[1],
6582: controllerData->FifoBuffer[2],
6583: controllerData->FifoBuffer[3],
6584: controllerData->FifoBuffer[3],
6585: transferCylinder)
6586: );
6587:
6588: controllerData->HardwareFailed = TRUE;
6589:
6590: ntStatus = FlInterpretError(
6591: controllerData->FifoBuffer[1],
6592: controllerData->FifoBuffer[2] );
6593:
6594: }
6595: }
6596: }
6597: }
6598: } else {
6599:
6600: #ifdef KEEP_COUNTERS
6601: FloppyNoSeek++;
6602: #endif
6603:
6604: }
6605:
6606: //
6607: // Start the operation on the DMA and floppy hardware.
6608: //
6609:
6610: if ( NT_SUCCESS( ntStatus ) ) {
6611:
6612: //
6613: // Map the transfer through the DMA hardware. How we do
6614: // it depends on whether we're using the user's buffer
6615: // or our own contiguous buffer.
6616: //
6617:
6618: if ( needToUseBuffer ) {
6619:
6620: KeFlushIoBuffers(
6621: controllerData->IoBufferMdl,
6622: !writeOperation,
6623: TRUE );
6624:
6625: //
6626: // We can ignore the logical address returned by
6627: // IoMapTransfer, since we're not using busmaster
6628: // stuff.
6629: //
6630:
6631: IoMapTransfer(
6632: controllerData->AdapterObject,
6633: controllerData->IoBufferMdl,
6634: controllerData->MapRegisterBase,
6635: controllerData->IoBuffer,
6636: &totalBytesOfTransfer,
6637: (BOOLEAN)writeOperation);
6638:
6639: } else {
6640:
6641: KeFlushIoBuffers( Irp->MdlAddress, !writeOperation, TRUE );
6642:
6643: IoMapTransfer(
6644: controllerData->AdapterObject,
6645: Irp->MdlAddress,
6646: controllerData->MapRegisterBase,
6647: (PVOID)( (ULONG) MmGetMdlVirtualAddress(Irp->MdlAddress)
6648: + bytesTransferredSoFar ),
6649: &totalBytesOfTransfer,
6650: (BOOLEAN)writeOperation);
6651: }
6652:
6653: //
6654: // Issue the READ or WRITE command
6655: //
6656:
6657: controllerData->FifoBuffer[0] = (UCHAR)
6658: ( ( transferHead << 2 ) | DisketteExtension->DeviceUnit );
6659: controllerData->FifoBuffer[1] = transferCylinder;
6660: controllerData->FifoBuffer[2] = transferHead;
6661: controllerData->FifoBuffer[3] = transferSector;
6662: controllerData->FifoBuffer[4] =
6663: driveMediaConstants->SectorLengthCode;
6664: controllerData->FifoBuffer[5] = (UCHAR)( transferSector - 1 +
6665: ( totalBytesOfTransfer >> byteToSectorShift ) );
6666: controllerData->FifoBuffer[6] =
6667: driveMediaConstants->ReadWriteGapLength;
6668: controllerData->FifoBuffer[7] = driveMediaConstants->DataLength;
6669:
6670: FloppyDump(
6671: FLOPSHOW,
6672: ("Floppy: R/W params:\n"
6673: "------ head+unit = %x\n"
6674: "------ cylinder = %x\n"
6675: "------ head = %x\n"
6676: "------ sector = %x\n"
6677: "------ seclen code = %x\n"
6678: "------ numsecs = %x\n"
6679: "------ rw gap len = %x\n"
6680: "------ datalen = %x\n",
6681: controllerData->FifoBuffer[0],
6682: controllerData->FifoBuffer[1],
6683: controllerData->FifoBuffer[2],
6684: controllerData->FifoBuffer[3],
6685: controllerData->FifoBuffer[4],
6686: controllerData->FifoBuffer[5],
6687: controllerData->FifoBuffer[6],
6688: controllerData->FifoBuffer[7])
6689: );
6690:
6691: if ( !writeOperation ) {
6692:
6693: ntStatus = FlIssueCommand(
6694: COMMND_READ_DATA + COMMND_MFM,
6695: DisketteExtension );
6696:
6697: } else {
6698:
6699: ntStatus = FlIssueCommand(
6700: COMMND_WRITE_DATA + COMMND_MFM,
6701: DisketteExtension );
6702: }
6703:
6704: if ( !NT_SUCCESS( ntStatus ) ) {
6705:
6706: FloppyDump(
6707: FLOPWARN,
6708: ("Floppy: read/write returned %x\n", ntStatus)
6709: );
6710: }
6711:
6712: }
6713:
6714: if ( NT_SUCCESS( ntStatus ) ) {
6715:
6716:
6717: if ( ( ( controllerData->FifoBuffer[0] & STREG0_END_MASK ) !=
6718: STREG0_END_NORMAL ) &&
6719: ( ( ( controllerData->FifoBuffer[0] & STREG0_END_MASK ) !=
6720: STREG0_END_ERROR ) ||
6721: ( controllerData->FifoBuffer[1] !=
6722: STREG1_END_OF_DISKETTE ) ||
6723: ( controllerData->FifoBuffer[2] != STREG2_SUCCESS ) ) ) {
6724:
6725: FloppyDump(
6726: FLOPWARN,
6727: ("Floppy: Status registers wrong after I/O\n")
6728: );
6729:
6730: controllerData->HardwareFailed = TRUE;
6731:
6732: ntStatus = FlInterpretError(
6733: controllerData->FifoBuffer[1],
6734: controllerData->FifoBuffer[2] );
6735:
6736: FloppyDump(
6737: FLOPWARN,
6738: ("Floppy: Register values are\n"
6739: "------ StatusRegister0 = %x\n"
6740: "------ StatusRegister1 = %x\n"
6741: "------ StatusRegister2 = %x\n"
6742: "------ actualCylinder = %x\n"
6743: "------ actualHead = %x\n"
6744: "------ actualSector = %x\n"
6745: "------ actualSectorLengthCode = %x\n",
6746: controllerData->FifoBuffer[0],
6747: controllerData->FifoBuffer[1],
6748: controllerData->FifoBuffer[2],
6749: controllerData->FifoBuffer[3],
6750: controllerData->FifoBuffer[4],
6751: controllerData->FifoBuffer[5],
6752: controllerData->FifoBuffer[6])
6753: );
6754: }
6755:
6756: }
6757:
6758: if ( !NT_SUCCESS( ntStatus ) ) {
6759:
6760: //
6761: // Operation failed. Recalibrate drive & try again.
6762: //
6763:
6764: FloppyDump(
6765: FLOPWARN,
6766: ("Floppy: operation failed. Recalibrating...\n")
6767: );
6768:
6769: ntStatus2 = FlRecalibrateDrive( DisketteExtension );
6770:
6771: if ( NT_SUCCESS( ntStatus2 ) ) {
6772:
6773: retryCount++;
6774:
6775: } else {
6776:
6777: //
6778: // Ugh, we can't even recalibrate the drive. Force
6779: // ourselves out of this nasty loop.
6780: //
6781:
6782: retryCount = RECALIBRATE_RETRY_COUNT;
6783:
6784: fatalError = TRUE;
6785:
6786: FloppyDump(
6787: FLOPWARN,
6788: ("Floppy: Operation AND recalibrate failed\n")
6789: );
6790: }
6791: }
6792:
6793: if ( retryCount == RECALIBRATE_RETRY_COUNT ) {
6794:
6795: //
6796: // The retry count is exhausted. If the FIFO has
6797: // overrun, reset the retry count and increment
6798: // the secondary retry count - FIFO overruns mean that
6799: // another device is hogging the DMA, so give the floppy
6800: // another chance to make good.
6801: //
6802:
6803: if ( controllerData->FifoBuffer[1] & STREG1_DATA_OVERRUN ) {
6804:
6805: if ( secondaryRetryCount < OVERRUN_RETRY_COUNT ) {
6806:
6807: secondaryRetryCount++;
6808:
6809: retryCount = 0;
6810:
6811: } else {
6812:
6813: //
6814: // It looks like another device is STILL hogging
6815: // the DMA. Before failing, try disabling the
6816: // FIFO, if it exists.
6817: //
6818:
6819: if ( controllerData->ControllerConfigurable ) {
6820:
6821: if ( fifoDisabled ) {
6822:
6823: //
6824: // We already disabled it, and still
6825: // failed. Exit with failure.
6826: //
6827:
6828: fatalError = TRUE;
6829:
6830: } else {
6831:
6832: FloppyDump(
6833: FLOPINFO,
6834: ("Floppy: disabling FIFO\n")
6835: );
6836:
6837: controllerData->FifoBuffer[0] = 0;
6838: controllerData->FifoBuffer[1] =
6839: COMMND_CONFIGURE_IMPLIED_SEEKS +
6840: COMMND_CONFIGURE_DISABLE_FIFO +
6841: COMMND_CONFIGURE_DISABLE_POLLING;
6842: controllerData->FifoBuffer[2] = 0;
6843:
6844: ntStatus = FlIssueCommand(
6845: COMMND_CONFIGURE,
6846: DisketteExtension );
6847:
6848: if ( NT_SUCCESS( ntStatus ) ) {
6849:
6850: fifoDisabled = TRUE;
6851: }
6852: }
6853:
6854: } else {
6855:
6856: //
6857: // No FIFO to disable. Just exit with error.
6858: //
6859:
6860: fatalError = TRUE;
6861: }
6862: }
6863:
6864: } else {
6865:
6866: //
6867: // Not an overrun error.
6868: //
6869:
6870: fatalError = TRUE;
6871: }
6872: }
6873:
6874: //
6875: // Flush the DMA adapter buffers.
6876: //
6877:
6878: if ( needToUseBuffer ) {
6879:
6880: IoFlushAdapterBuffers(
6881: controllerData->AdapterObject,
6882: controllerData->IoBufferMdl,
6883: controllerData->MapRegisterBase,
6884: controllerData->IoBuffer,
6885: totalBytesOfTransfer,
6886: (BOOLEAN)writeOperation);
6887:
6888: } else {
6889:
6890: IoFlushAdapterBuffers(
6891: controllerData->AdapterObject,
6892: Irp->MdlAddress,
6893: controllerData->MapRegisterBase,
6894: (PVOID)( (ULONG) MmGetMdlVirtualAddress( Irp->MdlAddress )
6895: + bytesTransferredSoFar ),
6896: totalBytesOfTransfer,
6897: (BOOLEAN)writeOperation);
6898: }
6899:
6900: } while ( ( !NT_SUCCESS( ntStatus ) ) &&
6901: ( retryCount < RECALIBRATE_RETRY_COUNT ) );
6902:
6903: if ( NT_SUCCESS( ntStatus ) ) {
6904:
6905: if ( ( !writeOperation ) && ( needToUseBuffer ) ) {
6906:
6907: //
6908: // copy data from contiguous buffer
6909: //
6910:
6911: FloppyDump(
6912: FLOPSHOW,
6913: ("Floppy: Reading to address %lx\n",
6914: userBuffer + bytesTransferredSoFar)
6915: );
6916:
6917: RtlMoveMemory(
6918: (PVOID)( userBuffer + bytesTransferredSoFar ),
6919: controllerData->IoBuffer,
6920: totalBytesOfTransfer );
6921: }
6922:
6923: //
6924: // If this was a read of the very first sector, check the
6925: // media descriptor byte to verify that we have the right
6926: // media type.
6927: //
6928:
6929: if ( ( startingSectorOfTransfer == 0 ) && ( !writeOperation ) ) {
6930:
6931: mediaDescriptor = *( userBuffer + MEDIA_DESCRIPTOR_OFFSET );
6932: FloppyDump(
6933: FLOPSHOW,
6934: ("Floppy: First sector read: media descriptor is: 0x%x\n",
6935: mediaDescriptor)
6936: );
6937:
6938: mediaType = 0;
6939:
6940: switch ( mediaDescriptor ) {
6941:
6942: case MEDIA_DESCRIPTOR_160K: {
6943:
6944: mediaType = F5_160_512;
6945: break;
6946: }
6947:
6948: case MEDIA_DESCRIPTOR_180K: {
6949:
6950: mediaType = F5_180_512;
6951: break;
6952: }
6953:
6954: case MEDIA_DESCRIPTOR_320K: {
6955:
6956: mediaType = F5_320_512;
6957: break;
6958: }
6959:
6960: case MEDIA_DESCRIPTOR_360K: {
6961:
6962: mediaType = F5_360_512;
6963: break;
6964: }
6965:
6966: case MEDIA_DESCRIPTOR_720K_OR_1220K: {
6967:
6968: if ( DisketteExtension->DriveType == DRIVE_TYPE_1200 ) {
6969:
6970: FloppyDump(
6971: FLOPSHOW,
6972: ("FLOPPY: 720K or 1220K ambiguity - going for "
6973: "1.2\n")
6974: );
6975: mediaType = F5_1Pt2_512;
6976:
6977: } else {
6978:
6979: FloppyDump(
6980: FLOPSHOW,
6981: ("FLOPPY: 720K or 1220K ambiguity - going for "
6982: "720\n")
6983: );
6984: mediaType = F3_720_512;
6985: }
6986:
6987: break;
6988: }
6989:
6990: case MEDIA_DESCRIPTOR_1440K_OR_2880K: {
6991:
6992: if (DisketteExtension->DriveType == DRIVE_TYPE_1440) {
6993:
6994: FloppyDump(
6995: FLOPSHOW,
6996: ("FLOPPY: 1440/2880KB ambiguity - going for "
6997: "1440KB\n")
6998: );
6999: mediaType = F3_1Pt44_512;
7000:
7001: } else {
7002:
7003: //
7004: // If the diskette media type is already 1.44
7005: // then leave it that way. The reasoning
7006: // here is that if it was a 2.88 then we
7007: // would have already figured that out.
7008: //
7009:
7010: if (DisketteExtension->MediaType !=
7011: F3_1Pt44_512) {
7012:
7013: FloppyDump(
7014: FLOPSHOW,
7015: ("FLOPPY: 1440/2880KB ambiguity - guess"
7016: " for 2880KB\n")
7017: );
7018: mediaType = F3_2Pt88_512;
7019:
7020: } else {
7021:
7022: FloppyDump(
7023: FLOPSHOW,
7024: ("FLOPPY: 1440/2880KB ambiguity - deduce"
7025: " 1440KB\n")
7026: );
7027:
7028: }
7029:
7030: }
7031:
7032: break;
7033: }
7034:
7035: default: {
7036:
7037: FloppyDump(
7038: FLOPDBGP,
7039: ("Floppy: unknown media descriptor %x\n",
7040: mediaDescriptor)
7041: );
7042: }
7043:
7044: }
7045: FloppyDump(
7046: FLOPSHOW,
7047: ("FLOPPY: After switch media type is: %x\n",mediaType)
7048: );
7049: if ( ( mediaType != 0 ) &&
7050: ( mediaType != DisketteExtension->MediaType ) ) {
7051:
7052: FloppyDump(
7053: FLOPSHOW,
7054: ("FLOPPY: media type doesn't agree with previous\n"
7055: "------ readid determination\n")
7056: );
7057:
7058:
7059: driveMediaType = DriveMediaLimits[
7060: DisketteExtension->DriveType].HighestDriveMediaType;
7061:
7062: while ( ( DriveMediaConstants[driveMediaType].MediaType !=
7063: mediaType ) &&
7064: ( driveMediaType > DriveMediaLimits[DisketteExtension->
7065: DriveType].LowestDriveMediaType ) ) {
7066:
7067: driveMediaType--;
7068: }
7069: // williamh - June 11 1993
7070: // make sure the data we read from the media are consistent
7071: // with the new media ID we are going to use.
7072: // if they do not match with the new media type,
7073: // we have a bogus media and should leave it unchanged.
7074: // Actually, the right thing to do here is to derive
7075: // a correct media type from what we read(sector 0).
7076: // I simply have no time for this.
7077:
7078: if (DriveMediaConstants[driveMediaType].MediaType ==
7079: mediaType &&
7080: *(userBuffer+MEDIA_DESCRIPTOR_SECTORS_PER_TRACK) ==
7081: DriveMediaConstants[driveMediaType].SectorsPerTrack &&
7082: *(userBuffer + MEDIA_DESCRIPTOR_NUM_OF_HEADS) ==
7083: DriveMediaConstants[driveMediaType].NumberOfHeads
7084: ){
7085:
7086: //
7087: // We only want to reset if the media types
7088: // actually match up. If they don't match
7089: // up, the maximum size is as good a guess.
7090: // as any.
7091: //
7092:
7093: FloppyDump(
7094: FLOPWARN,
7095: ("Floppy: New media type after lookup %x\n", mediaType)
7096: );
7097:
7098: DisketteExtension->MediaType = mediaType;
7099: DisketteExtension->DriveMediaType = driveMediaType;
7100:
7101: driveMediaConstants =
7102: &DriveMediaConstants[DisketteExtension->DriveMediaType];
7103:
7104: DisketteExtension->BytesPerSector =
7105: driveMediaConstants->BytesPerSector;
7106:
7107: DisketteExtension->ByteCapacity =
7108: ( driveMediaConstants->BytesPerSector ) *
7109: driveMediaConstants->SectorsPerTrack *
7110: ( 1 + driveMediaConstants->MaximumTrack ) *
7111: driveMediaConstants->NumberOfHeads;
7112:
7113: //
7114: // Since the I/O returned without failure, the gap,
7115: // density and wait times are correct. Only the
7116: // sectors, cylinders, and heads need to change.
7117: //
7118:
7119: if ((mediaDescriptor == MEDIA_DESCRIPTOR_720K_OR_1220K)
7120: ||
7121: (mediaDescriptor == MEDIA_DESCRIPTOR_1440K_OR_2880K)
7122: ) {
7123:
7124: //
7125: // The media indicator for 1.22 MB and 720KB are the
7126: // same, but it is possible to have a 1.44 floppy
7127: // formatted as a 1.22, so use the sectors per track
7128: // information from the floppy.
7129: //
7130:
7131: DisketteExtension->DriveMediaConstants
7132: .SectorsPerTrack =
7133: *( userBuffer + MEDIA_DESCRIPTOR_SECTORS_PER_TRACK );
7134:
7135: } else {
7136:
7137: DisketteExtension->DriveMediaConstants
7138: .SectorsPerTrack =
7139: driveMediaConstants->SectorsPerTrack;
7140:
7141: }
7142:
7143: DisketteExtension->DriveMediaConstants.NumberOfHeads =
7144: driveMediaConstants->NumberOfHeads;
7145: DisketteExtension->DriveMediaConstants.MaximumTrack =
7146: driveMediaConstants->MaximumTrack;
7147:
7148: } else {
7149:
7150: FloppyDump(
7151: FLOPDBGP,
7152: ("Floppy: Bogus media descriptor for size\n"
7153: "------ Guessing that max is ok\n")
7154: );
7155:
7156: }
7157: }
7158: }
7159:
7160: bytesTransferredSoFar += totalBytesOfTransfer;
7161: }
7162:
7163: } // while more transfers to be made for this request
7164:
7165: if ( fifoDisabled ) {
7166:
7167: //
7168: // We disabled the FIFO threshold. Restore it now.
7169: //
7170:
7171: controllerData->FifoBuffer[0] = 0;
7172: controllerData->FifoBuffer[1] = COMMND_CONFIGURE_IMPLIED_SEEKS +
7173: COMMND_CONFIGURE_FIFO_THRESHOLD + COMMND_CONFIGURE_DISABLE_POLLING;
7174: controllerData->FifoBuffer[2] = 0;
7175:
7176: ntStatus2 = FlIssueCommand( COMMND_CONFIGURE, DisketteExtension );
7177:
7178: if ( !NT_SUCCESS( ntStatus2 ) ) {
7179:
7180: FloppyDump(
7181: FLOPDBGP,
7182: ("Floppy: restoring FIFO after r/w gave %x\n", ntStatus2)
7183: );
7184: }
7185:
7186: }
7187:
7188: //
7189: // The bytesTransferred so far is correct even if there was an error.
7190: //
7191:
7192: Irp->IoStatus.Information = bytesTransferredSoFar;
7193:
7194: FloppyDump(
7195: FLOPIRPPATH,
7196: ("Floppy: done with read/write for irp %x extension %x\n",
7197: Irp,DisketteExtension)
7198: );
7199: return ntStatus;
7200: }
7201:
7202: NTSTATUS
7203: FlFormat(
7204: IN PDISKETTE_EXTENSION DisketteExtension,
7205: IN PIRP Irp
7206: )
7207:
7208: /*++
7209:
7210: Routine Description:
7211:
7212: This routine is called by the floppy thread to format some tracks on
7213: the diskette. This won't take TOO long because the FORMAT utility
7214: is written to only format a few tracks at a time so that it can keep
7215: a display of what percentage of the disk has been formatted.
7216:
7217: Arguments:
7218:
7219: DisketteExtension - pointer to our data area for the diskette to be
7220: formatted.
7221:
7222: Irp - pointer to the IO Request Packet.
7223:
7224: Return Value:
7225:
7226: STATUS_SUCCESS if the tracks were formatted; appropriate error
7227: propogated otherwise.
7228:
7229: --*/
7230:
7231: {
7232: LARGE_INTEGER headSettleTime;
7233: PCONTROLLER_DATA controllerData;
7234: PIO_STACK_LOCATION irpSp;
7235: PBAD_TRACK_NUMBER badTrackBuffer;
7236: PFORMAT_PARAMETERS formatParameters;
7237: PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
7238: NTSTATUS ntStatus;
7239: ULONG badTrackBufferLength;
7240: DRIVE_MEDIA_TYPE driveMediaType;
7241: UCHAR driveStatus;
7242: UCHAR numberOfBadTracks = 0;
7243: UCHAR currentTrack;
7244: UCHAR endTrack;
7245: UCHAR whichSector;
7246: UCHAR retryCount;
7247: BOOLEAN bufferOverflow = FALSE;
7248:
7249: FloppyDump(
7250: FLOPSHOW,
7251: ("Floppy: FlFormat...\n")
7252: );
7253:
7254: controllerData = DisketteExtension->ControllerData;
7255: formatParameters = (PFORMAT_PARAMETERS) Irp->AssociatedIrp.SystemBuffer;
7256: FloppyDump(
7257: FLOPFORMAT,
7258: ("Floppy: Format Params - MediaType: %d\n"
7259: "------ Start Cyl: %x\n"
7260: "------ End Cyl: %x\n"
7261: "------ Start Hd: %d\n"
7262: "------ End Hd: %d\n",
7263: formatParameters->MediaType,
7264: formatParameters->StartCylinderNumber,
7265: formatParameters->EndCylinderNumber,
7266: formatParameters->StartHeadNumber,
7267: formatParameters->EndHeadNumber)
7268: );
7269:
7270: irpSp = IoGetCurrentIrpStackLocation( Irp );
7271: badTrackBufferLength =
7272: irpSp->Parameters.DeviceIoControl.OutputBufferLength;
7273:
7274: //
7275: // Figure out which entry in the DriveMediaConstants table to use.
7276: // We know we'll find one, or FlCheckFormatParameters() would have
7277: // rejected the request.
7278: //
7279:
7280: driveMediaType =
7281: DriveMediaLimits[DisketteExtension->DriveType].HighestDriveMediaType;
7282:
7283: while ( ( DriveMediaConstants[driveMediaType].MediaType !=
7284: formatParameters->MediaType ) &&
7285: ( driveMediaType > DriveMediaLimits[DisketteExtension->DriveType].
7286: LowestDriveMediaType ) ) {
7287:
7288: driveMediaType--;
7289: }
7290:
7291: driveMediaConstants = &DriveMediaConstants[driveMediaType];
7292:
7293: //
7294: // Set some values in the diskette extension to indicate what we
7295: // know about the media type.
7296: //
7297:
7298: DisketteExtension->MediaType = formatParameters->MediaType;
7299: DisketteExtension->DriveMediaType = driveMediaType;
7300: DisketteExtension->DriveMediaConstants = DriveMediaConstants[driveMediaType];
7301:
7302: driveMediaConstants =
7303: &DriveMediaConstants[DisketteExtension->DriveMediaType];
7304:
7305: DisketteExtension->BytesPerSector = driveMediaConstants->BytesPerSector;
7306:
7307: DisketteExtension->ByteCapacity =
7308: ( driveMediaConstants->BytesPerSector ) *
7309: driveMediaConstants->SectorsPerTrack *
7310: ( 1 + driveMediaConstants->MaximumTrack ) *
7311: driveMediaConstants->NumberOfHeads;
7312:
7313: currentTrack = (UCHAR)( ( formatParameters->StartCylinderNumber *
7314: driveMediaConstants->NumberOfHeads ) +
7315: formatParameters->StartHeadNumber );
7316:
7317: endTrack = (UCHAR)( ( formatParameters->EndCylinderNumber *
7318: driveMediaConstants->NumberOfHeads ) +
7319: formatParameters->EndHeadNumber );
7320:
7321: FloppyDump(
7322: FLOPFORMAT,
7323: ("Floppy: Format - Starting/ending tracks: %x/%x\n",
7324: currentTrack,
7325: endTrack)
7326: );
7327:
7328: //
7329: // Set the data rate (which depends on the drive/media
7330: // type).
7331: //
7332:
7333: if ( controllerData->LastDriveMediaType != driveMediaType ) {
7334:
7335: ntStatus = FlDatarateSpecifyConfigure( DisketteExtension );
7336:
7337: if ( !NT_SUCCESS( ntStatus ) ) {
7338:
7339: return ntStatus;
7340: }
7341: }
7342:
7343: //
7344: // Format each track.
7345: //
7346:
7347: do {
7348:
7349: //
7350: // Seek to proper cylinder
7351: //
7352:
7353: controllerData->FifoBuffer[0] = DisketteExtension->DeviceUnit;
7354: controllerData->FifoBuffer[1] = (UCHAR)( ( currentTrack /
7355: driveMediaConstants->NumberOfHeads ) <<
7356: driveMediaConstants->CylinderShift );
7357:
7358: FloppyDump(
7359: FLOPFORMAT,
7360: ("Floppy: Format seek to cylinder: %x\n",
7361: controllerData->FifoBuffer[1])
7362: );
7363:
7364: ntStatus = FlIssueCommand( COMMND_SEEK, DisketteExtension );
7365:
7366: if ( NT_SUCCESS( ntStatus ) ) {
7367:
7368: if ( ( controllerData->FifoBuffer[0] & STREG0_SEEK_COMPLETE ) &&
7369: ( controllerData->FifoBuffer[1] == (UCHAR)( ( currentTrack /
7370: driveMediaConstants->NumberOfHeads ) <<
7371: driveMediaConstants->CylinderShift ) ) ) {
7372:
7373: //
7374: // Must delay HeadSettleTime milliseconds before
7375: // doing anything after a SEEK.
7376: //
7377:
7378: headSettleTime.LowPart = - ( 10 * 1000 *
7379: driveMediaConstants->HeadSettleTime );
7380: headSettleTime.HighPart = -1;
7381:
7382: KeDelayExecutionThread(
7383: KernelMode,
7384: FALSE,
7385: &headSettleTime );
7386:
7387: //
7388: // Read ID. Note that we don't bother checking the return
7389: // registers, because if this media wasn't formatted we'd
7390: // get an error.
7391: //
7392:
7393: controllerData->FifoBuffer[0] = DisketteExtension->DeviceUnit;
7394:
7395: ntStatus = FlIssueCommand(
7396: COMMND_READ_ID + COMMND_MFM,
7397: DisketteExtension );
7398:
7399: } else {
7400:
7401: FloppyDump(
7402: FLOPWARN,
7403: ("Floppy: format's seek returned bad registers\n"
7404: "------ Statusreg0 = %x\n"
7405: "------ Statusreg1 = %x\n",
7406: controllerData->FifoBuffer[0],
7407: controllerData->FifoBuffer[1])
7408: );
7409:
7410: controllerData->HardwareFailed = TRUE;
7411:
7412: ntStatus = STATUS_FLOPPY_BAD_REGISTERS;
7413: }
7414: }
7415:
7416: if ( !NT_SUCCESS( ntStatus ) ) {
7417:
7418: FloppyDump(
7419: FLOPWARN,
7420: ("Floppy: format's seek/readid returned %x\n", ntStatus)
7421: );
7422:
7423: return ntStatus;
7424: }
7425:
7426: //
7427: // Fill the buffer with the format of this track.
7428: //
7429:
7430: for ( whichSector = 1;
7431: whichSector <=
7432: (UCHAR)( driveMediaConstants->SectorsPerTrack );
7433: whichSector++ ) {
7434:
7435: controllerData->IoBuffer[( whichSector - 1 ) * 4] =
7436: currentTrack / driveMediaConstants->NumberOfHeads;
7437: controllerData->IoBuffer[( whichSector - 1 ) * 4 + 1] =
7438: currentTrack % driveMediaConstants->NumberOfHeads;
7439: controllerData->IoBuffer[( whichSector - 1 ) * 4 + 2] =
7440: whichSector;
7441: controllerData->IoBuffer[( whichSector - 1 ) * 4 + 3] =
7442: driveMediaConstants->SectorLengthCode;
7443:
7444: FloppyDump(
7445: FLOPFORMAT,
7446: ("Floppy - Format table entry %x - %x/%x/%x/%x\n",
7447: whichSector-1,
7448: controllerData->IoBuffer[(whichSector -1)*4],
7449: controllerData->IoBuffer[(whichSector -1)*4 + 1],
7450: controllerData->IoBuffer[(whichSector -1)*4 + 2],
7451: controllerData->IoBuffer[(whichSector -1)*4 + 3])
7452: );
7453: }
7454:
7455: //
7456: // Retry until success or too many retries.
7457: //
7458:
7459: retryCount = 0;
7460:
7461: do {
7462:
7463: ULONG length;
7464:
7465: length = driveMediaConstants->BytesPerSector;
7466:
7467: //
7468: // Map the transfer from the buffer to the disk.
7469: //
7470:
7471: KeFlushIoBuffers( controllerData->IoBufferMdl, FALSE, TRUE );
7472:
7473: IoMapTransfer(
7474: controllerData->AdapterObject,
7475: controllerData->IoBufferMdl,
7476: controllerData->MapRegisterBase,
7477: controllerData->IoBuffer,
7478: &length,
7479: TRUE );
7480:
7481: //
7482: // Issue command to format track
7483: //
7484:
7485: controllerData->FifoBuffer[0] = (UCHAR)
7486: ( ( ( currentTrack % driveMediaConstants->NumberOfHeads ) << 2 )
7487: | DisketteExtension->DeviceUnit );
7488: controllerData->FifoBuffer[1] =
7489: driveMediaConstants->SectorLengthCode;
7490: controllerData->FifoBuffer[2] =
7491: driveMediaConstants->SectorsPerTrack;
7492: controllerData->FifoBuffer[3] =
7493: driveMediaConstants->FormatGapLength;
7494: controllerData->FifoBuffer[4] =
7495: driveMediaConstants->FormatFillCharacter;
7496:
7497: FloppyDump(
7498: FLOPFORMAT,
7499: ("Floppy: format command parameters\n"
7500: "------ Head/Unit: %x\n"
7501: "------ Bytes/Sector: %x\n"
7502: "------ Sectors/Cylinder: %x\n"
7503: "------ Gap 3: %x\n"
7504: "------ Filler Byte: %x\n",
7505: controllerData->FifoBuffer[0],
7506: controllerData->FifoBuffer[1],
7507: controllerData->FifoBuffer[2],
7508: controllerData->FifoBuffer[3],
7509: controllerData->FifoBuffer[4])
7510: );
7511: ntStatus = FlIssueCommand(
7512: COMMND_FORMAT_TRACK + COMMND_MFM,
7513: DisketteExtension );
7514:
7515: IoFlushAdapterBuffers(
7516: controllerData->AdapterObject,
7517: controllerData->IoBufferMdl,
7518: controllerData->MapRegisterBase,
7519: controllerData->IoBuffer,
7520: length,
7521: TRUE );
7522:
7523: if ( !NT_SUCCESS( ntStatus ) ) {
7524:
7525: FloppyDump(
7526: FLOPDBGP,
7527: ("Floppy: format returned %x\n", ntStatus)
7528: );
7529: }
7530:
7531: if ( NT_SUCCESS( ntStatus ) ) {
7532:
7533: //
7534: // Check the return bytes from the controller.
7535: //
7536:
7537: if ( ( controllerData->FifoBuffer[0] &
7538: ( STREG0_DRIVE_FAULT |
7539: STREG0_END_INVALID_COMMAND ) )
7540: || ( controllerData->FifoBuffer[1] &
7541: STREG1_DATA_OVERRUN ) ||
7542: ( controllerData->FifoBuffer[2] != 0 ) ) {
7543:
7544: FloppyDump(
7545: FLOPWARN,
7546: ("Floppy: format had bad registers\n"
7547: "------ Streg0 = %x\n"
7548: "------ Streg1 = %x\n"
7549: "------ Streg2 = %x\n",
7550: controllerData->FifoBuffer[0],
7551: controllerData->FifoBuffer[1],
7552: controllerData->FifoBuffer[2])
7553: );
7554:
7555: controllerData->HardwareFailed = TRUE;
7556:
7557: ntStatus = FlInterpretError(
7558: controllerData->FifoBuffer[1],
7559: controllerData->FifoBuffer[2] );
7560: }
7561: }
7562:
7563: } while ( ( !NT_SUCCESS( ntStatus ) ) &&
7564: ( retryCount++ < RECALIBRATE_RETRY_COUNT ) );
7565:
7566: if ( !NT_SUCCESS( ntStatus ) ) {
7567:
7568: driveStatus = READ_CONTROLLER(
7569: &controllerData->ControllerAddress->DRDC.DiskChange );
7570:
7571: if ( (DisketteExtension->DriveType != DRIVE_TYPE_0360) &&
7572: (driveStatus & DSKCHG_DISKETTE_REMOVED) ) {
7573:
7574: //
7575: // The user apparently popped the floppy. Return error
7576: // rather than logging bad track.
7577: //
7578:
7579: return ntStatus;
7580: }
7581:
7582: //
7583: // Log the bad track.
7584: //
7585:
7586: FloppyDump(
7587: FLOPDBGP,
7588: ("Floppy: track %x is bad\n", currentTrack)
7589: );
7590:
7591: if ( badTrackBufferLength >= (ULONG)
7592: ( ( numberOfBadTracks + 1 ) * sizeof( BAD_TRACK_NUMBER ) ) ) {
7593:
7594: badTrackBuffer = (PBAD_TRACK_NUMBER)
7595: Irp->AssociatedIrp.SystemBuffer;
7596:
7597: badTrackBuffer[numberOfBadTracks] = ( BAD_TRACK_NUMBER )
7598: currentTrack;
7599:
7600: } else {
7601:
7602: bufferOverflow = TRUE;
7603: }
7604:
7605: numberOfBadTracks++;
7606: }
7607:
7608: currentTrack++;
7609:
7610: } while ( currentTrack <= endTrack );
7611:
7612: if ( ( NT_SUCCESS( ntStatus ) ) && ( bufferOverflow ) ) {
7613:
7614: ntStatus = STATUS_BUFFER_OVERFLOW;
7615: }
7616:
7617: return ntStatus;
7618: }
7619:
7620: BOOLEAN
7621: FlCheckFormatParameters(
7622: IN PDISKETTE_EXTENSION DisketteExtension,
7623: IN PFORMAT_PARAMETERS FormatParameters
7624: )
7625:
7626: /*++
7627:
7628: Routine Description:
7629:
7630: This routine checks the supplied format parameters to make sure that
7631: they'll work on the drive to be formatted.
7632:
7633: Arguments:
7634:
7635: DisketteExtension - a pointer to our data area for the diskette to
7636: be formatted.
7637:
7638: FormatParameters - a pointer to the caller's parameters for the FORMAT.
7639:
7640: Return Value:
7641:
7642: TRUE if parameters are OK.
7643: FALSE if the parameters are bad.
7644:
7645: --*/
7646:
7647: {
7648: PDRIVE_MEDIA_CONSTANTS driveMediaConstants;
7649: DRIVE_MEDIA_TYPE driveMediaType;
7650:
7651: //
7652: // Figure out which entry in the DriveMediaConstants table to use.
7653: //
7654:
7655: driveMediaType =
7656: DriveMediaLimits[DisketteExtension->DriveType].HighestDriveMediaType;
7657:
7658: while ( ( DriveMediaConstants[driveMediaType].MediaType !=
7659: FormatParameters->MediaType ) &&
7660: ( driveMediaType > DriveMediaLimits[DisketteExtension->DriveType].
7661: LowestDriveMediaType ) ) {
7662:
7663: driveMediaType--;
7664: }
7665:
7666: if ( DriveMediaConstants[driveMediaType].MediaType !=
7667: FormatParameters->MediaType ) {
7668:
7669: return FALSE;
7670:
7671: } else {
7672:
7673: driveMediaConstants = &DriveMediaConstants[driveMediaType];
7674:
7675: if ( ( FormatParameters->StartHeadNumber >
7676: (ULONG)( driveMediaConstants->NumberOfHeads - 1 ) ) ||
7677: ( FormatParameters->EndHeadNumber >
7678: (ULONG)( driveMediaConstants->NumberOfHeads - 1 ) ) ||
7679: ( FormatParameters->StartCylinderNumber >
7680: driveMediaConstants->MaximumTrack ) ||
7681: ( FormatParameters->EndCylinderNumber >
7682: driveMediaConstants->MaximumTrack ) ||
7683: ( FormatParameters->EndCylinderNumber <
7684: FormatParameters->StartCylinderNumber ) ) {
7685:
7686: return FALSE;
7687:
7688: } else {
7689:
7690: return TRUE;
7691: }
7692: }
7693: }
7694:
7695: VOID
7696: FloppyUnloadDriver(
7697: IN PDRIVER_OBJECT DriverObject
7698: )
7699:
7700: /*++
7701:
7702: Routine Description:
7703:
7704: This routine is called by the system to remove the driver from memory.
7705:
7706: When this routine is called, there is no I/O being done to this device.
7707: The driver object is passed in, and from this the driver can find and
7708: delete all of its device objects, extensions, etc.
7709:
7710: Arguments:
7711:
7712: DriverObject - a pointer to the object associated with this device
7713: driver.
7714:
7715: Return Value:
7716:
7717: None.
7718:
7719: --*/
7720:
7721: {
7722: UNREFERENCED_PARAMETER( DriverObject );
7723:
7724: // signal FloppyThread() to unload itself
7725: // disable interrupts from controller(s?)
7726: // delete everything that's been allocated
7727: }
7728:
7729: PCONTROLLER
7730: FlGetControllerBase(
7731: IN INTERFACE_TYPE BusType,
7732: IN ULONG BusNumber,
7733: PHYSICAL_ADDRESS IoAddress,
7734: ULONG NumberOfBytes,
7735: BOOLEAN InIoSpace,
7736: PBOOLEAN MappedAddress
7737: )
7738:
7739: /*++
7740:
7741: Routine Description:
7742:
7743: This routine maps an IO address to system address space.
7744:
7745: Arguments:
7746:
7747: BusType - what type of bus - eisa, mca, isa
7748: IoBusNumber - which IO bus (for machines with multiple buses).
7749: IoAddress - base device address to be mapped.
7750: NumberOfBytes - number of bytes for which address is valid.
7751: InIoSpace - indicates an IO address.
7752: MappedAddress - indicates whether the address was mapped.
7753: This only has meaning if the address returned
7754: is non-null.
7755:
7756: Return Value:
7757:
7758: Mapped address
7759:
7760: --*/
7761:
7762: {
7763: PHYSICAL_ADDRESS cardAddress;
7764: ULONG addressSpace = InIoSpace;
7765: PCONTROLLER Address;
7766:
7767: HalTranslateBusAddress(
7768: BusType,
7769: BusNumber,
7770: IoAddress,
7771: &addressSpace,
7772: &cardAddress
7773: );
7774:
7775: //
7776: // Map the device base address into the virtual address space
7777: // if the address is in memory space.
7778: //
7779:
7780: if (!addressSpace) {
7781:
7782: Address = MmMapIoSpace(
7783: cardAddress,
7784: NumberOfBytes,
7785: FALSE
7786: );
7787:
7788: *MappedAddress = !!Address;
7789:
7790:
7791: } else {
7792:
7793: Address = (PCONTROLLER)cardAddress.LowPart;
7794: *MappedAddress = FALSE;
7795:
7796: }
7797:
7798: return Address;
7799:
7800: }
7801:
7802: VOID
7803: FlLogErrorDpc(
7804: IN PKDPC Dpc,
7805: IN PVOID DeferredContext,
7806: IN PVOID SystemContext1,
7807: IN PVOID SystemContext2
7808: )
7809:
7810: /*++
7811:
7812: Routine Description:
7813:
7814: This routine is merely used to log an error that we had to reset the device.
7815:
7816: Arguments:
7817:
7818: Dpc - The dpc object.
7819:
7820: DeferredContext - A pointer to the controller data.
7821:
7822: SystemContext1 - Unused.
7823:
7824: SystemContext2 - Unused.
7825:
7826: Return Value:
7827:
7828: Mapped address
7829:
7830: --*/
7831:
7832: {
7833:
7834: PIO_ERROR_LOG_PACKET errorLogEntry;
7835: PCONTROLLER_DATA controllerData = DeferredContext;
7836:
7837: errorLogEntry = IoAllocateErrorLogEntry(
7838: controllerData->DriverObject,
7839: (UCHAR)(sizeof(IO_ERROR_LOG_PACKET))
7840: );
7841:
7842: if ( errorLogEntry != NULL) {
7843:
7844: errorLogEntry->ErrorCode = IO_ERR_RESET;
7845: errorLogEntry->SequenceNumber = 0;
7846: errorLogEntry->MajorFunctionCode = 0;
7847: errorLogEntry->RetryCount = 0;
7848: errorLogEntry->UniqueErrorValue = 0;
7849: errorLogEntry->FinalStatus = STATUS_SUCCESS;
7850: errorLogEntry->DumpDataSize = 0;
7851:
7852: IoWriteErrorLogEntry(errorLogEntry);
7853:
7854: }
7855:
7856: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.