Acorn ANFS 4.08.53

Tests IFR bit 2 (SR complete) to check for a shift register transfer complete. If SR is not set, returns A=5 to pass the service call on. If SR is set, saves registers, reads the VIA ACR, clears and restores the SR mode bits from ws_0d64, then dispatches the TX completion callback via the operation type stored in tx_op_type. The indexed handler performs the completion action (e.g. resuming background print spooling) before returning with A=0 to claim the service call.

Validates the TX operation type in Y against the dispatch table range, saves the current JSR protection mask, sets protection bits 2-4, then dispatches through the PHA/RTS trampoline using the table at set_rx_buf_len_hi. If Y >= &86, skips the protection setup and dispatches directly.

Initialise ADLC hardware and Econet workspace. Reads station ID via &FE18 (INTOFF side effect), performs a full ADLC reset (adlc_full_reset), then checks for Tube co-processor via OSBYTE &EA and stores the result in l0d63. Issues NMI claim service request (OSBYTE &8F, X=&0C). Falls through to init_nmi_workspace to copy the NMI shim to RAM.

Copies 32 bytes of NMI shim code from ROM (listen_jmp_hi) to &0D00, then patches the current ROM bank number into the self-modifying code at &0D07. Clears tx_src_net, need_release_tube, and tx_op_type to zero. Reads station ID into tx_src_stn (&0D22). Sets ws_0d60 and ws_0d62 to &80 to mark TX complete and Econet initialised. Finally re-enables NMIs via INTON (&FE20 read).

Default NMI handler for incoming scout frames. Checks if the frame is addressed to us or is a broadcast. Installed as the NMI target during idle RX listen mode. Tests SR2 bit0 (AP = Address Present) to detect incoming data. Reads the first byte (destination station) from the RX FIFO and compares against our station ID. Reading &FE18 also disables NMIs (INTOFF side effect).

Reads the second byte of an incoming scout (destination network). Checks for network match: 0 = local network (accept), &FF = broadcast (accept and flag), anything else = reject. Installs the scout data reading loop handler at &8102.

Handles scout reception errors and end-of-frame conditions. Reads SR2 and tests AP|RDA (bits 0|7): if neither set, the frame ended cleanly and is simply discarded. If unexpected data is present, performs a full ADLC reset. Also serves as the common discard path for address/network mismatches from nmi_rx_scout and scout_complete -- reached by 5 branch sites across the scout reception chain.

Processes a completed scout frame. Writes CR1=&00 and CR2=&84 to disable PSE and suppress FV, then tests SR2 for FV (frame valid). If FV is set with RDA, reads the remaining scout data bytes in pairs into the buffer at &0D3D. Matches the port byte (&0D40) against open receive control blocks to find a listener. On match, calculates the transfer size via tx_calc_transfer, sets up the data RX handler chain, and sends a scout ACK. On no match or error, discards the frame via scout_error.

Receives the data frame after the scout ACK has been sent. First checks AP (Address Present) for the start of the data frame. Reads and validates the first two address bytes (dest_stn, dest_net) against our station address, then installs continuation handlers to read the remaining data payload into the open port buffer.

Handler chain: &81DC (AP+addr check) -> &81F0 (net=0 check) -> &8206 (skip ctrl+port) -> &8239 (bulk data read) -> &826D (completion)

Selects between the normal bulk RX handler (&8239) and the Tube RX handler based on bit 1 of rx_src_net (tx_flags). If normal mode, loads the handler address &8239 and checks SR1 bit 7: if IRQ is already asserted (more data waiting), jumps directly to nmi_data_rx_bulk to avoid NMI re-entry overhead. Otherwise installs the handler via set_nmi_vector and returns via RTI.

Common error/abort entry used by 12 call sites. Checks tx_flags bit 7: if clear, does a full ADLC reset and returns to idle listen (RX error path); if set, jumps to tx_result_fail (TX not-listening path).

Reads data payload bytes from the RX FIFO and stores them into the open port buffer at (open_port_buf),Y. Reads bytes in pairs (like the scout data loop), checking SR2 between each pair. SR2 non-zero (FV or other) -> frame completion at &826D. SR2 = 0 -> RTI, wait for next NMI to continue.

Reached when SR2 non-zero during data RX (FV detected). Same pattern as scout completion (&812C): disables PSE (CR2=&84, CR1=&00), then tests FV and RDA. If FV+RDA, reads the last byte. If extra data available and buffer space remains, stores it. Proceeds to send the final ACK via &82E4.

Sends a scout ACK or final ACK frame as part of the four-way handshake. If bit7 of &0D4A is set, this is a final ACK -> completion (&88C6). Otherwise, configures for TX (CR1=&44, CR2=&A7) and sends the ACK frame (dst_stn, dst_net from &0D3D, src_stn from &FE18, src_net=0). The ACK frame has no data payload -- just address bytes.

After writing the address bytes to the TX FIFO, installs the next NMI handler from &0D4B/&0D4C (saved by the scout/data RX handler) and sends TX_LAST_DATA (CR2=&3F) to close the frame.

Continuation of ACK frame transmission. Reads our station ID from &FE18 (INTOFF side effect), tests TDRA via SR1, and writes station + network=0 to the TX FIFO, completing the 4-byte ACK address header. Then checks rx_src_net bit 7: if set, branches to start_data_tx to begin the data phase. Otherwise writes CR2=&3F (TX_LAST_DATA) and falls through to post_ack_scout for scout processing.

Called after the scout ACK has been transmitted. Processes the received scout data stored in the buffer at &0D3D-&0D48. Checks the port byte (&0D40) against open receive blocks to find a matching listener. If a match is found, sets up the data RX handler chain for the four-way handshake data phase. If no match, discards the frame.

Adds the transfer count to the RXCB buffer pointer (4-byte addition). If a Tube transfer is active, re-claims the Tube address and sends the extra RX byte via R3, incrementing the Tube pointer by 1.

Finalises a received data transfer. Calls advance_rx_buffer_ptr to update the 4-byte buffer pointer with the transfer count (and handle Tube re-claim if needed). Adds the buffer bytes remaining to the base address, then subtracts 8 from the RXCB buffer length to account for the scout overhead. Clears the RXCB flag byte and sends the final ACK via ack_tx. On Tube transfers, releases the Tube claim before resetting to idle listen.

Checks whether a Tube transfer is active by ANDing bit 1 of l0d63 with rx_src_net (tx_flags). If a Tube claim is held, calls release_tube to free it before returning. Used as the clean-up path after RXCB completion and after ADLC reset to ensure no stale Tube claims persist.

Copies scout data bytes (offsets 4-11) from the RX scout buffer at &0D3D into the open port buffer. Checks bit 1 of rx_src_net (tx_flags) to select the write path: direct memory store via (open_port_buf),Y for normal transfers, or Tube data register 3 write for Tube transfers. Calls advance_buffer_ptr after each byte. Falls through to release_tube on completion. Handles page overflow (Y wrap) by branching to scout_page_overflow.

Tests need_release_tube (&98) bit 7: if set, the Tube has already been released and the subroutine just clears the flag. If clear (Tube claim held), calls tube_addr_data_dispatch with A=&82 to release the claim, then clears the release flag via LSR (which shifts bit 7 to 0). Called after completed RX transfers and during discard paths to ensure no stale Tube claims persist.

Checks the control byte at l0d30 for immediate operation codes (&81-&88). Codes below &81 or above &88 are out of range and discarded. Codes &87-&88 (HALT/CONTINUE) bypass the protection mask check. For &81-&86, converts to a 0-based index and tests against the immediate operation mask at &0D61 to determine if this station accepts the operation. If accepted, dispatches via the immediate operation table. Builds the reply by storing data length, station/network, and control byte into the RX buffer.

Sets up the port buffer to receive remote procedure data. Copies the 2-byte remote address from &0D32 into the execution address workspace at &0D66, then jumps to the common receive path at c81c1. Used for operation types &83 (JSR), &84 (UserProc), and &85 (OSProc).

Sets up workspace offsets for receiving POKE data. port_ws_offset=&2E, rx_buf_offset=&0D, then jumps to the common data-receive path at c81af.

Sets up a buffer at &88C1 (length #&01FC) for the machine type query response. Falls through to set_rx_buf_len_hi to configure buffer dimensions, then branches to set_tx_reply_flag.

Writes &0D2E to port_ws_offset/rx_buf_offset, sets scout_status=2, then calls tx_calc_transfer to send the PEEK response data back to the requesting station.

Stores data length, source station/network, and control byte into the RX buffer header area for port-0 immediate operations. Then disables SR interrupts and configures the VIA shift register for shift-in mode before returning to idle listen.

Adds one to the counter at &A2-&A5 (port_buf_len low/high, open_port_buf low/high), cascading overflow through all four bytes. Called after each byte is stored during scout data copy and data frame reception to track the current write position in the receive buffer.

Pushes (tx_done_exit - 1) on the stack so RTS returns to tx_done_exit, then does JMP (l0d66) to call the remote JSR target routine. When that routine returns via RTS, control resumes at tx_done_exit.

Handler for TX operation type &84. Loads the remote address from l0d66/l0d67 into X/A and sets Y=8 (Econet event number), then falls through to tx_done_fire_event to call OSEVEN.

Calls the ROM service entry point with X=l0d66, Y=l0d67. This invokes an OS-level procedure on behalf of the remote station, then exits via tx_done_exit.

Sets bit 2 of rx_flags (&0D61), enables interrupts, and spin-waits until bit 2 is cleared (by a CONTINUE from the remote station). If bit 2 is already set, skips to exit.

Clears bit 2 of rx_flags (&0D61), releasing any station that is halted and spinning in tx_done_halt.

Main TX initiation entry point (called via trampoline at &06CE). Copies dest station/network from the TXCB to the scout buffer, dispatches to immediate op setup (ctrl >= &81) or normal data transfer, calculates transfer sizes, copies extra parameters, then enters the INACTIVE polling loop.

Entry point for the Econet line idle detection loop. Saves the TX index in rx_remote_addr, pushes two timeout counter bytes onto the stack, and loads Y=&E7 (CR2 value for TX preparation). Loads the INACTIVE bit mask (&04) into A and falls through to intoff_test_inactive to begin polling SR2 with interrupts disabled.

Disables NMIs via two reads of &FE18 (INTOFF), then polls SR2 for the INACTIVE bit (bit 2). If INACTIVE is detected, reads SR1 and writes CR2=&67 to clear status, then tests CTS (SR1 bit 4): if CTS is present, branches to tx_prepare to begin transmission. If INACTIVE is not set, re-enables NMIs via &FE20 (INTON) and decrements the 3-byte timeout counter on the stack. On timeout, falls through to tx_line_jammed.

Reached when the INACTIVE polling loop times out without detecting a quiet line. Writes CR2=&07 (FC_TDRA|2_1_BYTE|PSE) to abort the TX attempt, pulls the 3-byte timeout state from the stack, and stores error code &40 ('Line Jammed') in the TX control block via store_tx_error.

Configures the ADLC for frame transmission. Writes CR2=Y (&E7: RTS|CLR_TX_ST|CLR_RX_ST|FC_TDRA| 2_1_BYTE|PSE) and CR1=&44 (RX_RESET|TIE) to enable TX with interrupts. Installs the nmi_tx_data handler at &86E0. Sets need_release_tube flag via SEC/ROR. Writes the 4-byte destination address (dst_stn, dst_net, src_stn, src_net=0) to the TX FIFO. For Tube transfers, claims the Tube address; for direct transfers, sets up the buffer pointer from the TXCB.

Handler for control byte &88. Sets scout_status=3 and branches to store_status_copy_ptr, skipping the 4-byte address addition (no address parameters needed for a machine type query).

Sets A=3 (scout_status for PEEK) and branches to tx_ctrl_store_and_add to store the status and perform the 4-byte transfer address addition.

Sets A=2 (scout_status for POKE) and falls through to tx_ctrl_store_and_add to store the status and perform the 4-byte transfer address addition.

Shared path for PEEK (A=3) and POKE (A=2). Stores A as the scout status byte at rx_port (&0D40), then performs a 4-byte addition with carry propagation, adding bytes from the TXCB (nmi_tx_block+&0C to +&0F) into the transfer address workspace at &0D1E-&0D21. Falls through to tx_ctrl_proc which checks the loop boundary, then continues to tx_calc_transfer and tx_ctrl_exit.

Sets scout_status=2 and calls tx_calc_transfer directly (no 4-byte address addition needed for procedure calls). Shared by operation types &83-&85.