TRS-80 DOS - NEWDOS/80 v2.0 for the Model III - SYS0/SYS Disassembled

The DOS Jump Table provides fixed entry points for system services. These vectors allow programs to call DOS functions without needing to know the actual location of the routines.

The DOS Ready jump at 402DH is the standard warm-start entry point. When a program terminates or an error occurs, execution returns here.

This 46-byte area is zero-initialized at load time (appears as NOPs in the disassembly). At runtime, these locations hold system state information including track cache tables for each drive, timer callback data, and temporary storage used by various DOS routines.

This instruction clears a memory location pointed to by HL.

This jump redirects control to the DOS Ready command handler.

The DOS signature byte A5H is used to validate DOS presence and integrity.

This area contains the core disk drive configuration including the current drive number, drive select register shadow, disk geometry parameters, and Drive Parameter Blocks (DPBs) for up to 4 drives. Many values are initialized from the boot sector during DOS startup. The DPB for each drive contains information about track count, sector size, and FCB buffer pointers.

This area continues the system variable storage with additional Drive Parameter Block entries for Drive 3, FCB buffer templates, and system pointers. The FFH bytes indicate uninitialized buffer positions; 00H bytes are reserved for runtime data.

This is the main DOS Ready handler, the warm-start entry point called when programs terminate or errors occur. It performs system reinitialization and displays the DOS READY prompt.

This section contains a series of system service calls using RST 28H with various function codes, followed by jump vectors to service routines.

This table provides jump vectors for file operations including open, close, read, write, and seek. These are the primary file I/O entry points used by programs.

Short service routines for system operations.

Default FCB (File Control Block) template and additional storage area.

More FCB template data and system variables.

This routine converts hexadecimal values to ASCII representation for display. It processes both bytes of DE register pair.

This complex routine handles keyboard input, system state checks, and timer management. It interfaces with the Model III keyboard hardware at memory-mapped locations 3801H-3810H.

These routines handle character processing, including lowercase to uppercase conversion for the Model III keyboard.

This section implements a timer callback system that manages periodic tasks. It maintains a linked list of timer callbacks with countdown values. Self-modifying code at 4511H, 4512H, 4583H, and 459CH is used throughout.

This routine scans the Model III keyboard hardware at memory-mapped I/O addresses 3801H-3810H. It checks for BREAK key combinations and handles interrupt restoration.

This is the interrupt service routine entry point, called by the hardware interrupt system. It executes system calls and manages interrupt context.

These routines prepare FDC commands for read and write operations. The routines set up command bytes that will be sent to the WD1793 FDC via port F0H.

Main entry point for disk sector read and write operations. This routine handles both read (88H) and write (A8H/A9H) commands, sets up the FDC, and manages the data transfer.

This routine prepares the FDC for a sector operation by setting drive parameters, handling side selection for double-sided drives, and adjusting for density and precompensation.

This is the main FDC sector read routine using Model III port-based I/O. The WD1793 FDC is accessed via ports F0H-F4H. This routine sets up the FDC registers, issues the read command, and handles the high-speed data transfer from the FDC Data Register (port F3H).

This routine modifies the FDC transfer loop code to handle different sector sizes. It changes instruction opcodes and operands at runtime to optimize the data transfer loop.

This is the FDC operation completion handler, reached when the data transfer finishes. It restores the system state, reads the final FDC status, and issues the Force Interrupt command to terminate the operation.

This routine examines the FDC status byte returned from the operation and converts it into DOS error codes. It prioritizes critical errors and handles retry logic for transient errors.

This routine handles the return from FDC operations, either with success (A=0) or with an error code in Register A.

These routines handle drive restoration (recalibration to track 0) and FDC command execution with proper step rate and verify settings.

These short utility routines check FDC status and select the active drive by outputting to port F4H.

This routine handles drive selection changes, saves and restores FDC track positions, copies drive parameter blocks, and performs drive initialization including restore operations. It manages the complex state associated with changing the active drive in a multi-drive system.

This routine waits for the FDC to complete its current operation by polling the busy flag. It includes a small delay loop before checking status to allow the FDC time to begin processing.

This routine waits for the disk's index pulse to be detected, indicating the disk is spinning. It polls the FDC status register watching for the index bit (bit 1) to change state. Returns error code 08H if timeout occurs.

This is the main file open routine. It searches the directory for a matching filename, validates access permissions, sets up the FCB (File Control Block) with extent information, and prepares for file operations.

This section handles extent table management during file operations. It processes extent entries, validates directory entries, updates extent information in the FCB, and manages file allocation.

This small routine calculates sector counts from extent length values. It extracts the extent length (bits 0-4) and performs arithmetic to determine the number of sectors.

These routines support file read/write operations, including buffer management, directory updates, and position tracking within the FCB structure.

This routine sets up for directory search operations by examining file access flags and managing the call stack for proper return handling.

This routine completes the directory search operation by restoring registers from the stack and calling any registered completion handlers.

This routine validates the file access mode stored in the FCB flags (IX+01H). Access modes 0-4 are valid; mode 5+ returns error 25H.

This routine checks if the current file position is at or past the end-of-file marker. Returns appropriate error codes for EOF conditions.

Common error return point that restores the stack pointer and returns with error code in Register A and NZ FLAG set.

This routine provides the RST 28H supervisor call interface, extracting function codes and parameters from the stack.

This routine handles string input/output operations with a length limit specified in IX+09H. It processes characters one at a time, calling a character handler routine.

Main file read routine. Reads data from the current file position, handles record advancement, and manages EOF conditions.

Performs the actual sector read operation by validating access mode, checking EOF, and calling the low-level FDC read routine.

This is the entry point for file write operations that should update the EOF marker when writing past the current end-of-file. Loads A with F6H (11110110b) as the AND mask for FCB flag testing, then jumps to the common write code at 49DDH. The F6H mask preserves bit 4 (modified/dirty flag) during the flag test at 4A30H.

Entry point 49DBH is for file write operations that should NOT update the EOF marker (used for random-access overwrites within existing file bounds). Loads A with E6H (11100110b) which clears bit 4 during the flag test. The common code at 49DDH handles the actual write operation: stores the mode flag, calls directory setup, performs the sector write, updates FCB position pointers, and optionally updates EOF markers based on the mask value.

This routine handles directory updates when files are modified, ensuring extent information is written back to disk and managing the "dirty" flags in the FCB.

This routine performs the actual physical sector write to disk with retry logic. It handles both read-modify-write operations and direct writes, with up to 3 retry attempts on error.

This is the main device driver entry point for character I/O operations. It handles device selection, string mode operations, and manages the buffer pointer for sequential I/O.

Calculates the address in the sector buffer corresponding to the current sector offset within the file.

Context: HL points to the current node in the linked device-driver chain. Each node is a small record whose fields (relative to the base of the node) are:
  +0 low byte of “match” value
  +1 high byte of “match” value
  +2 flag/mask byte
  +3 reserved
  +4 reserved
  +5 low byte of address of next node (or 00H for end of chain)
  +6 high byte of address of next node
DE holds the 16-bit key being searched for; B holds a flag mask. The loop walks every node until either a match is found or the chain pointer is 0000H.

Five small supervisor-call handlers reached via the SVC dispatcher (RST 28H). Each sets up register values for a particular file-positioning or inquiry function then falls into the common “apply position” code at 4B25H or 4B35H. On entry IX points to the caller’s FCB; DE points to the caller’s parameter block.

Common path reached by all the seek SVCs above. On entry: HL = target record number; C = target sector offset within that record; IX = FCB pointer. The routine sets the “position valid” bit in the FCB, compares the target position against the current position, and if they differ it flushes any dirty sector buffer before updating the FCB fields.

Two short routines that print a NUL/CR-terminated string by calling the Model III ROM character-output routine at 001BH, which prints the character in A to the current cursor position on the video display.

Entry point for all RST 28H supervisor calls. When code executes RST 28H the CPU pushes PC and jumps to 0028H; from there a JP at 0028H leads here. The byte immediately following RST 28H in the caller’s code is the function code. The dispatcher pops this code from the stack, looks it up in a jump table, and invokes the corresponding handler.

Reads successive bytes from a driver record (via the lazy-read helper at 4C0AH) and constructs an FCB (File Control Block) in the buffer pointed to by HL. The driver record is stored with a length prefix followed by the filename bytes. Returns Z on success with HL pointing to the completed FCB; returns error code in A on failure (C flag set).

Helper called by 4BCDH. DE is a running pointer into the driver-record data already in the 4300H–43FFH page buffer. On entry the routine increments E, then fetches the byte at (DE). If the byte is non-zero it returns it in A immediately. If it is zero (meaning the current 256-byte page is exhausted) it calls the file-read SVC at 4436H to load the next page, resets DE to 4300H, and then returns the refreshed byte.

Converts an FCB granule reference (from the extent table) into the physical disk parameters needed by the FDC: track, sector, and byte offset. Entry: A = granule index; IY = 4280H (system parameter block). Returns HL = pointer into the 4300H sector buffer for this granule’s data; DE = drive/physical-sector address pair. The sub-routines at 4C37H, 4C39H, and 4C42H are factored integer-multiply helpers.

Three small arithmetic helpers used by the granule converter and elsewhere.
4C37H: 8×8 multiply returning 16-bit product.
4C39H: 16÷8 divide returning quotient and remainder (wraps 4C42H).
4C42H: 16×8 multiply (also used standalone) by shift-and-add.
4C57H/4C59H: 16-bit divide of HL by C, returning quotient in HL and remainder in A.

Divides the 16-bit value in HL by the 8-bit divisor in C (set to 5 at 4C57H for the granule calculation, or passed in directly at 4C59H). Returns quotient in HL, remainder in A. Uses a standard bit-serial non-restoring algorithm with a 16-bit loop counter in B.

Walks a table pointed to by HL, comparing each entry against the string pointed to by BC. The table entries are NULL (00H) terminated. Returns with HL pointing just past the matching entry if found, or falls to 4C8EH (no-match path) if not.