Partial sector transfers on old floppy disk controllers on old floppy-disk based operative systems (FDOS)

Question

Background

I'm writing a simulation of a very simple computer (in VHDL), that is similar to 1960s/1970s computers in capacity and architecture. It previously could load a program from a ROM, but I wanted to expand functionality to load a program from an address in storage. The RAM and resouces are very limited on the computer, so it seems like being able to load individual bytes was a good idea. Partial sector transfer seems to have been a feature in old floppy disk controllers:

• FDC37C78 Floppy Disk Controller (datasheet)
• WD1002-05/HDO Winchester/Floppy Disk Controller (datasheet)
• TMS9909 Floppy Disk Controller (datasheet)
• An Inside Look at MS-DOS, Tim Paterson (article)

In the disk controller I've written, a sector is buffered from the drive, and the DMA is then requested to transfer the data (used DREQ and DACK pins similar to FDC37C78. ) I write parameters for the read operation using memory-mapped I/O addresses for each register in the disk controller. The parameters are:

• Address for first sector
• Sectors to read in total
• Offset for first sector
• Total bytes to read in last sector

The controller is able to do a partial sector transfer on the first and last sector, and treats all sectors in between as full transfers.

I want to write a controller that is similar to what was (or is) actually used on similar computers, so that I can learn about the constraints and parts and mechanisms of that, and why different solutions were used.

The vhd file for "disk_ctrl" entity that supports only read operation so far: https://snippet.host/kvcunz.

Question

What I want to ask is, what are the trends for how floppy disk-based operative systems ("FDOS") solved partial sector transfer, assuming there was a trend that they used partial sector transfer. The alternative I can see to my design in my simulation is to let the disk controller output the whole block on the data bus, but then let the OS (via CPU) or DMA only apply write_enable signals for the desired data in the block. I am interested in the big picture for the advancement of computers, and to be able to "put myself in the shoes of" engineers of early computers, and what challenges they had to solve.

Answer 1

The Intel 8272 floppy controller may be a little late for you, but since you mention MS-DOS above you may still find this relevant. The 8272 has the ability to perform a partial transfer using the Terminal Count signal. Once the signal is sent, then the controller will continue to read / write data from / to the disc drive, but will not transfer any more bytes to / from memory.

This makes it possible to perform a partial read, as long as the bytes required are at the beginning of the sector. However it requires the CPU or some other piece of hardware to monitor the number of bytes transferred and set Terminal Count at the correct moment.

If Terminal Count is set during a write, the remaining bytes in the sector are written as zeroes.

The only operating systems I am aware of which use the 8272 and perform partial reads are CP/M on the Amstrad PCW and Spectrum +3, LocoScript on the PCW, and +3DOS on the +3 (all floppy access code in these systems shares a common heritage). These computers use the CPU to read data from the floppy controller one byte at a time, rather than DMA hardware, and so can simply count the number of bytes transferred and stop the transfer when the required number have been read.

On the above systems, a partial read is performed only in one specific situation: When logging in a disc, the first ten bytes of the boot sector are read to determine the filesystem parameters. All other I/O is done in complete sectors.