16 bit Assembly

FAT12 Floppy Disk Access

Floppy Disk FAT12 Configuration

Here is a summary of the tasks required. I will add more detail and code about each of these processes as the code is developed.

A floppy disk formatted as 1.44Mb has the following layout. 80 cylinders from 0 to 79, 18 sectors 1 10 18, 2 heads 0 to 1.

All sectors are 512 bytes.
The BOOT sector is always the first sector of the disk and must not be overwritten with data. It contains the disk parameters, and if bootable it will contain the booting instruction.
There are usually 2 FAT's, which should be identical, otherwise there has been a disk error. They are both 9 sectors in size.
The Root Directory contains all the file information about the files stored on the disk. It is 14 sectors in size and can hold up to 224 entries.
Everything after the Root Directory is a data storage area.

Converting a Start Clusters or Allocation Clusters to a CHS

CHS is Short for Cylinder Head and Sector.

When calculating the sector position on the disk you must use the following method to get the head, cylinder and sector numbers. This example assumes the cluster address is 54.

Ignore the BOOT sector, as it is at sector 0 for the purpose of this calculation. Add 2x9 sectors for the FAT's + 14 sectors for the Root Directory = 32.
54 + 32 = 86
86 / 18 = 4 Cylinders
4 * 18 = 72 sectors in the cylinders
86 - 72 = 14 Sectors remainder
The number of cylinders is even, so the Head=0, odds are Head=1
There are 2 heads so divide 4 cylinders by 2 = cylinder 2 on the disk

Therefore the data block is at Head=0, Cylinder=2. Sector=14.

If you need to work is backwards from a CHS to an Allocation Cluster do this. For example using the previous convertion.

Cylinders * 18 * Heads = 2 * 18 * 2 = 72
Add the sectors 72 + 14 = 86
Deduct Offset to the data area 86 - 32 = FAT block 54

Don't forget that each FAT block is 3 bytes, so to find the start of the 3 bytes in the Allocation Table divide by 2 and multiply by 3. Hence (54 / 2) * 3 = starts at 81 bytes in the first sector of the FAT.

Extracting Allocation Cluster Numbers

The FAT contains a 3 byte addressing system. Each set of 3 bytes points to 2 blocks in the Disk Data Area.

The FAT starts counting from block zero, The first 3 bytes will usually be F0 FF FF, these represent blocks 0 and 1. F0 FF indicates if the disk needs scanning etc.., Block 1 is where the disk label would be if it had a data area.

To find the correct data block number you need to manipulate the bytes as shown in the image below, using the address from the above FAT example, we get Allocation Clusers 2 and 3 which are byte values 03 40 00.

Reads a Cluster from FAT12

>The code sample following shows a method of achieving this in assembly code.
; Extract the Cylinder, Head and Sector from the FAT ; There are 2 clusters enclosed in each 3 byte alloction block ; they are both 12bit numbers that identify a sector. ; Pass SI = Address of an allocation block a FAT that has been ; copied in to memory. ; Pass CX = Byte 0 (even number) or 1 (odd numbers) ; indicates which of the 2 clusters is to be returned ; Returns BX = Next Cluster to be read SubConvertFAT12AllocationBlock: MOV AH, 0x00 CMP CX, 0x0000 JNE 0x02 ; Jump to first number (even numbers) JMP 0x0E ; Jump to extract the second value (odd numbers) ; Even numbered blocks LODSB ; Read byte 1 MOV BL, AL LODSB ; Read byte 2 SHL AL, 0x04 ; shift the bits to remove the upper 4 bits SHR AL, 0x04 MOV BH, AL ; BX is now the Cluster / Allocation Value JMP 0x11 ; Jump to exit ; Odd numbered blocks LODSB ; Read byte 1 and ignore LODSB ; Read byte 2 SHR AL, 0x04 MOV AH, AL LODSB ; Read byte 3 MOV BH, AL MOV BL, 0x00 SHR BX, 0x04 ; shift the bits to form a 12 bit number ADD BL, AH ; BX is now the Cluster / Allocation Value RET

Reads Both Clusters from FAT12 Allocation block

The code sample following is an alternate method of achieving this by returning both cluster values.
; Calculates the FAT12 value in a cluster block ; Pass SI=Offset of the Cluster in FAT ; Returns BX=Cluster 1 (even), DX=Cluster 2 (odd) SubGetFAT12Clusters: MOV AH, 0x00 LODSB MOV BX, AX Load each byte to a register LODSB MOV CX, AX LODSB MOV DX, AX SHL CX, 0x04 SHR CL, 0x04 MOV BH, CL ; BX now Cluster 1 SHL DX, 0x04 ADD DL, CH ; DX now Cluster 2 RET

Writes Clusters to a FAT12 Allocation block

The code sample following converts the clusters back into a FAT12 allocation block.
; Writes the FAT12 allocation block at the memory address ; Pass BX=Cluster 1 (even), DX=Cluster 2 (odd) ; DI=Offset to the FAT block ; Returns Nothing SubSetFAT12Clusters: MOV AH, 0x00 MOV AL, BL STOSB ; Store First Byte MOV CL, BH SHL CL, 0x04 SHL DX, 0x04 MOV CH, DL SHR CH, 0x04 SHR CX, 0x04 MOV AL, CL STOSB ; Store second bytes MOV AL, DH STOSB ; Store third byte RET

Calculate the offset to a FAT12 Cluster block

The code sample following calculates to location of a cluster / allocation block within the FAT.
; Calculates to Start of the Allocation Block to be ; Read or Written to. ; Pass CX=Cluster Number, SI=Address of the start of FAT in Memory ; Returns SI=Address offset of the Allocation Block to read SubGetFAT12Offset: ; OK Checked MOV AX, CX SHL CX, 0x01 JNC 0x01 ; Odd number must be -1 DEC AX MOV DX, 0x0002 CALL SubMathsDivide MOV CX, 0x0003 CALL SubMathsMultiply ADD SI, AX ; Move the result to SI RET

Converts a Cluster Number to a Disk sector CHS

The code sample following converts a cluster number to its
CHS (Cylinder, Head, Sector) on the Disk.
; Convert an Allocation Block into a CHS value ; Pass BX=Cluster number ; Returns (CX)CH=Cylinders, CL=Sectors, DH=Head SubConvertAllocationToCHS: ; Tested OK MOV DH, 0x00 MOV CX, 0x0000 ADD BX, 0x20 ; Add the number of FAT sectors CMP BX, 0x12 JLE 0x07 INC CH ; Count the total cylinders SUB BX, 0x12 ; -18 sectors each loop (division by 18) JMP 0xF4 SHR CH, 1 ; divide by 2 - CH = Cylinder Number JNC 0x02 MOV DH, 0x01 ; Head 1 if Cylinder number was Odd MOV CL, BL ; CL = Sectors RET

Converts CHS sector to a Cluster Number

The code sample following calculates the Cluster number from the CHS (Cylinder, Head, Sector).
; Convert CHS to the Cluster Number ; Pass CX=Cylinder and Sector, DH=Head ; Returns BX=Cluster SubConvertCHSToCluster: MOV AH, 0x00 MOV BX, 0x0012 MOV AL, DH ; Assign value of the Heads MOV DL, CL ; DX Holds the left over sectors MOV CL, CH ; Assign Cylinder number MOV CH, 0x00 ADD CX, CX ; multiply cylinders by 2 ADD AX, CX ; Add to AX for total used cylinders PUSH EDX ; use stack to remember the Sectors in DL MUL BX ; x18 for total number Sectors POP EDX ; Recover DX from the stack MOV DH, 0x00 ADD AX, DX ; Add remaining sectors SUB AX, 0x0020 ; Deduct 32 FAT sectors = Cluster number MOV BX, AX RET

Last Update 24/12/2021