fdrawcmd.sys — IOCTL Codes

The size of the input buffer depends on the number of sectors in the track. The FD_FORMAT_PARAMS structure should be immediately followed by a list of FD_ID_HEADER structures, with each header followed by the data to be written to its data field.

This command requires an 82078 or later FDC, with unpredictable results if used on older controllers. Use IOCTL_FD_GET_FDC_INFO to determine whether a suitable controller version is present.

For a typical read, set the input structure as follows:

• flags to FD_OPTION_MFM, to use normal MFM encoding.
• phead to the physical head to read from (0 or 1).
• cyl, head, sector and size to the values expected in the ID header of the first sector to read from the disk. The controller will fail to find the sector unless all these values match the sector on disk.
• eot to the sector number after the final sector to read. e.g. to read sectors 5 to 10, use an eot value of 11.
• gap to 10, so the controller ignores a small region around the write splice points. Consult a floppy controller specification for futher details.
• datalen to 255, unless you're using 128-byte sectors when you should use 128 instead.

Use IOCTL_FD_GET_RESULT to determine the failure point in multi-sector reads. The sector value will hold the sector number with the problem.

This function allows exclusive access to the controller to be held even when the drive is idle. When locked, attempts to use another drive on the same controller will fail.

The drive lock can be acquired multiple times, but each must have a corresponding IOCTL_FD_UNLOCK_FDC.

The main use of this function is to allow immediate access to another drive on the same controller, without waiting for the motor-off idle timeout to expire.

Like other requests, it is only processed when the previous request has completed. This means you can't use it to interrupt in-progress commands for various copy protection tricks!

By default, the drive motor is automatically started before any commands that need it. IOCTL_FD_MOTOR_ON starts the motor and allows a 750ms settle-time before completing the request. If the motor is already running the function completes immediately.

The motor is stopped a short time after the drive becomes idle, and the controller is released for other programs. The default idle timeout is 1 second, but it can be extended using IOCTL_FD_SET_MOTOR_TIMEOUT. Also note that the 750ms spin-up delay does not count against the timeout value.

This function uses the 2-drive raw track reading technique discovered by Vincent Joguin, as implemented in his Disk2FDI utility. It requires a second drive to be present, containing a 1.44M formatted disk (can be write-protected). The main drive holds the double-density disk to raw-read from.

Before using this function, select the data rate to be used by the read using IOCTL_FD_SET_DATA_RATE. This can be zero for 500Kbps, which will return both clock and data bits from the source disk. A value of two for 250Kbps will return only data or clock bits, depending on how the controller syncs to the data stream on the main drive.

In the function parameters, the flags value should be FD_OPTION_MFM for the PC-formatted disk, and head is the physical head to raw-read from. The size parameter determines how much data to read from the main disk. As the starting point for the read is semi-random, you'll need to read 16-32K to give a long enough bitstream to recover the required information. It may also be necessary to retry if a long enough stream can't be found. Some controllers may not support 32K reading - use IOCTL_FD_GET_REMAIN_COUNT to ensure that the remain count is zero after the read, indicating the controller completed your full request.

500Kbps reading of standard-format Amiga disks is quite reliable, as the original disks are written in a single pass. Most other disks (including PC disks) are formatted in one pass, but have data written to sectors afterwards. This separate writing creates seams in the bitstream where the new writing started and stopped in the bitstream. The noise around these splice points will disturb the controller sync during a raw reads, causing it to return patches of zero bytes instead of the real data. For this reason 500Kbps reading is generally not possible.

250Kbps reading is supported by more controllers, and the only way to read disks containing the splice points described above. This reading is still not a straightforward task, particularly since you only have data bits to work with. Assumptions must be made about patterns in the data, such as the A1A1A1 sequence used by address marks, and it's also necessary to check data CRCs to ensure the stream was complete enough. On top of this you'll also need to reassemble the order of sectors on the track, which is a topic beyond what I can describe here!

• 0 for 500Kbps (high-density 1.44M)
• 1 for 300Kbps (double-density for 5.25" drives)
• 2 for 250Kbps (double-density 720K for 3" and 3.5" drives)
• 3 for 1Mbps (extra-density, for 2.88M drives)

By default, the driver uses the disk change line to ensure a disk is present before commands that need one. This works well with modern 3.5" drives, but causes problems with older drives (including 3" drives) that lack the change line.

A zero input value disables the disk check, and a non-zero value enables it. You may optionally provide an output buffer to receive the previous value.

On success, the count member of FD_SCAN_RESULT contains the number of headers found. A count of zero indicates either an unformatted track or that there were no sectors found matching the current data rate / encoding. The headers are returned in the order they are encountered, beginning from the index hole.

The output buffer must be large enough to hold the scanned number of sector headers, which may not be known in advance. Space for 32 headers will be enough in most situations, but more is recommended when dealing with unknown disks.

To support writing a number of copy-protection schemes, it's necessary to interrupt the controller part way through a write command. This function sets the number of bytes to write before interrupting the controller, and applies to all write and format commands.

To interrupt sector writes, simply set the number of bytes to stop after. If the count is exactly the sector size, the write will terminate before the CRC is written to disk, generating a sector with specific data but a CRC error. Using a smaller count allows around 6K of known data to be written to 8K sectors.

To interrupt formats you need to allow 4 bytes for each sector to write. Remember that stopping immediately after the final sector will be just before the ID header CRC is written, and also before the data address mark and the data field itself.

In both cases, the controller requires a small amount of time between accepting the final data and it being written to disk. The finetune parameter in the structure allows an additional delay (in microseconds) for this data to be processed. My own experiments showed that 86us was required in 250Kbps MFM mode, with an additional 32us for each byte to allow beyond that.