Model I ROM Explained – Part 1

0000-0002 Disables the interrupts, clears the A register, then jumps to initialisation routine at 674H

This routine is used for scanning strings. It compares the character pointed to by the HL Register Pair with the character pointed to by the return address on the top of the STACK. If they are not equal an SN ERROR will result; if they are equal then the return address on the STACK will be incremented to bypass the test character and control will be passed to RST 10H logic.

This routine increments HL and tests the characters pointed to by the HL Register Pair. It will bypass any spaces and characters 9 and 10 (shifted left and down arrows respectively). Upon return from this routine HL will point to the next non-blank character.

This routine inputs a byte from an input device. When calling, DE = starting address of DCB of device. On exit, A = byte received from device, Z set if device ready. Uses AF.

This routine compares two 16 bit values in HL and DE and sets the S and Z flags accordingly (they are set in the same way as for a normal 8 bit CP). All registers are unchanged except for A.

This routine outputs a byte to a device. When calling, A = output byte, DE = starting address of DCB of device. On exit, Z set if device ready. Uses AF.

Returns a combination of STATUS flags and unique numeric values in the A Register according to the data mode flag (40AFH). Integer = NZ/C/M/E and A is -1; String = Z/C/P/E and A is 0; Single Precision = NZ/C/P/O and A is 1; and Double Precision is NZ/NC/P/E and A is 5.

Jumps to 400CH which contains C9H (RET) under Level II BASIC. This vector is only used by Disk BASIC. It is called by the BREAK key routine, and can be used to intercept the BREAK key logic.

Keyboard scanning routine. Performs an instantaneous scan of the keyboard. If no key is depressed control is returned to the caller with the A Register and status Register set to zero. If any key (except the BREAK key) is active the ASCII value for that character is returned in the A-register.

Of the 3 keyboard scanning routines, this is the most fundamental one. If no key is pressed when the CALL is executed, the code falls through with A = 00H. If you want to wait for a key to be pressed, you would use CALL 0049Hor you would write a routine that jumps back to the call if A is 0.

This location passes control to 400FH which contains a RET (C9H) under Level II. This location is only used by a Disk system.

Character print routine. A CALL 33H will print a character at the current cursor position. The A Register must contain the ASCII code for the character or graphics figure that is to be printed before CALLing this routine. The DE Register Pair is used by the routine.

This is the system entry point for all interrupts. It contains a jump to a section of code in the Communications Region designed to field interrupts.

Character LPRINT routine. Same as 33H but outputs to line printer. A call to 003BH causes the character contained in the A-register to be sent to the printer. A line count is maintained by the driver in the DCB. When a full page has been printed (66 lines), the line count is reset and the status Register returned to the caller is set to zero.

Control codes recognized by the printer driver are:

• 00=Returns the printer status in the upper two bits of the A-register and sets the status as zero if not busy, and non-zero if busy.
• OB=Unconditionally skips to the top of the next page.
• OC=Resets the line count (DCB 4) and compares its previous value to the lines per page (DCB 3) value. If the line count was zero, no action is taken. If the line count was non-zero then a skip to the top form is performed.
• OD=Line terminator. Causes line count to be incremented and tested for full page. Usually causes the printer to begin printing.

A call to 0049H returns as soon as any key on keyboard is pressed, exactly how the INKEY$ function works in BASIC. ASCII value for character entered is returned in A register. If you don’t want the program to hold while waiting for a key, you would use CALL 002BHinstead.

Character input routine. This routine is the same as 2BH except that it will not return until a key is pressed, which often makes it more useful than 2BH. Character is returned in the A Register (AF and DE used).

This is a table of control characters used by BASIC.

This is a delay loop. The BC Register Pair is used as the loop counter. The duration of the delay, in microseconds, is the value of BC times 14.66. Register A is used.

0066 is the location to which program control jumps when the RESET button is pressed (Non Maskable Interrupt address).

This part of the initialization routine checks to see if a disk drive is connected. If so, it will jump to 00H. (This is why the reset button will reinitialize DOS.)

This is part of the Level II initialization procedure. It moves a block of memory from 18F7H to 191EH up to 4080H to 40A7H (reserved RAM area).

Note: 4080H-408DH is a division support routine.

This loads 40A7H with the I/O buffer location address 41E8H. (40A7H is the I/O buffer pointer and can be changed to relocate the buffer.)

0091H-0104H – The rest of the initialization routine. First, it fills the RAM locations pointing to all 28 DOS BASIC commands, set them to point to ?L3 ERROR, ask MEMORY SIZE ?, sets the memory pointers accordingly and prints RADIO SHACK LEVEL II BASIC, then it jumps to 1A19H which is the entry point for the BASIC command mode.

The “MEMORY SIZE” message is located here

0132, 0135, 0138 These are the entry points for the POINT, SET and the RESET commands in that order, see Part 2 for more data on the graphics routines

Common code for SET/RESET/POINT– A will be 0 if POINT, 80H if SETand 1 for RESET.

A CALL 1C9H will clear the screen, select 64 characters and home the cursor. All registers are used.

To use a ROM call to clear the screen, CALL 01C9H. The cursor is reset to the home position, which is 3C00H.

This is part of the RANDOMroutine which takes a value out of the REFRESH register, stores it in location 40ABH and then returns.

A call to 01D3H reseeds the random number seed (location 40AB) with the current contents of the refresh register.

NOTE: To run a RANDOM (seed the random number generator) via a ROM call just call CALL 01D3H. This causes the contents of R (memory refresh) to be stored in 40ABH. The entire 24 bit seed is stored in 40AAH-40ACH.

CALL 212H will select the cassette unit specified in A-Register and start the motor. Units are numbered from one. Put 00H in A Register to turn on cassette 1, or O1H to turn on cassette 2. All registers are used.

To use a ROM call to turn on the cassette, execute the following instructions: LD A,0and then CALL 0212H

Alternately displays and clears an asterisk in the upper right hand comer. Uses all registers.

Read One Byte: Reads one byte from the currently selected unit. The byte read is returned in the A-register. All other registers are preserved

This routine will read a byte from tape. A CALL 235H will return with the byte read from tape in the A Register BC, DE and HL are unchanged

To use a ROM call to read a character from cassette (after the cassette has been turned on and leader and sync have been found), CALL 0235H. The input character will be in the A register. Again, the routine at 0235H must be called frequently enough to sustain the 500 baud rate if more than one character is to be read.

Routine waits for timing pulse, and then performs a timing loop. When the time is up it tests the tape for a bit, which will be “1” if present and “0” if not. A CALL 241H is used by 235H eight times to input one byte.

0264 Writes the byte in the A Register to tape. BC, DE and HL are unchanged by a CALL 264H

Writes the byte in the A Register to tape. BC, DE and HL are unchanged by a CALL 264H.

To use a ROM call to write a character onto cassette tape (after the cassette has been turned on and leader and sync have been recorded), load the character into the A Register And CALL 0264H. If more than one character is to be written, the CALL 0264H must be executed with sufficient frequency to sustain the 500 baud recording rate. The routine provides automatic timing.

A call to 0284H writes a Level II leader on currently selected unit. The leader consists of 256 (decimal) binary zeros followed by a A5H. Uses the B and A registers.

Places the double asterisk in the right top corner to show that the sync byte has been found

This routine is commonly used by the SYSTEM routine to read the last two bytes on tape which give the entry point. A JP (HL) can then be executed to jump to the location specified, when used for this purpose. Only HL is used by this routine

This is a general purpose output routine which outputs a byte from the A Register to video, tape or printer. In order to use it, the location 409CH must be loaded with -1 for tape, 0 for video or 1 for the line printer.
Note: 409CH holds the current output device flag: -1=cassette, 0=video and 1=printer.

This routine outputs a byte to device determined by byte stored at (409CH) – FFH=Tape, 0=Video, l=Printer. When calling, A = output byte. Uses AF. Warning: This routine CALLs a Disk BASIC link at address 41ClH which may have to be “plugged” with a RETurn (C9H) instruction.

A Print routine which performs the same function as 33H except that it doesn’t destroy the contents of the DE Register Pair. This means that all the general purpose registers are saved, which is often desirable

To use a ROM call to print a single character at the current cursor position, and to update the cursor position, load the ASCII value of the character into the A Register And then CALL 033AH.

To display special functions using a ROM call, load the A Register with the value given below for the special function and then CALL 033AH.

1. Backspace and erase previous character – 08H
2. Carriage return and linefeed – 0DH
3. Turn on cursor – 0EH
4. Turn off cursor – 0FH
5. Convert to 32 characters per line mode – 17H
6. Backspace cursor – 18H
7. Advance cursor one position – 19H
8. Downward line feed – 1AH
9. Upward line feed – 1BH
10. Home (cursor to upper left corner) – 1CH
11. Move cursor to beginning of current line – 1DH
12. Erase from cursor position to end of line – 1EH
13. Erase from cursor position to end of screen – 1FH

This is one of the general purpose input routines (see 5D9 and 1BB3 also). This routine inputs a string from the keyboard, up to a maximum of 240 characters (F0H), and echoes them to the screen. It puts this data into a buffer located at the address pointed to by the buffer pointer at 40A7H. (e.g. If 40A7H contains 5000H the data will be stored from 5000H onwards). The string is terminated with a zero byte. The program returns from this routine as soon as the ENTER key has been pressed. When it does so, HL contains the start address of the input string and B contains the length of the string. (RST 10H can be used to make HL point to the first character of the string, if required.).
Note: 40A7H-40A8H holds the input Buffer pointer.

Waits for keypress

This routine resets device type flag at 409CH to zero (output to video display), also outputs a carriage return to the line printer if printer is not at beginning of line (determined by checking the contents of the printer line position flag at 409BH – if flag contains zero, printer is at start of line). Note that if printer line position flag does not contain zero and the printer is not on line, the computer will “hang up” waiting for a “printer ready” signal.

This is the LPRINT routine. All registers are saved. The byte to be printed should be in the A register.

This routine is called from a RST 14 (with a device code of 01H in Register B), RST 1C (with a device code of 02H in Register B), and RST 24 (with a device code of 04H in Register B).

On entry, BC shoud contain the Device Control Block and A may contain (if needed) the output control/data

According to the original ROM notes, this is the Character I/O Linkage to Device Driver routine. On entry Register Pair DE to point at the Device Control Block and Register A will hold the output or control data, if any. On exit, the codes depend on whether a byte or a control code was passed. If this was an I/O operation, Register A will hold that input/output data byte. If this was a I/O control operation, Register A will hold the device status and the Z FLAG will be set if the device is ready.

This is the keyboard driver. It scans the keyboard and converts the bit pattern obtained to ASCII and stores it in the A register.

According to the original ROM notes, this is the Keyboard Driver. On exit, Register A to hold the data byte received (or 0 if none). On entry, [IX] should point to the DCB, which is laid out as follows:

• DCB + 0 = DCB Type
• DCB + 1 = Driver Address (LSB)
• DCB + 2 = Driver Addres (MSB)
• DCB + 3 = 0
• DCB + 4 = 0
• DCB + 5 = 0
• DCB + 6 = “K”
• DCB + 7 = “I”

This is the video driver. On entry, the character to be displayed should be in the C register. On exit, A would contain the character at the cursor (if called for an INPUT). This routine handles scrolling etc.

Register IX points to the DCB, so IX+0 = the DCB type, IX+1 = LSB of the Driver Address, IX+2 = MSB of the Driver Address, IX+3 = LSB of the Cursor Position, IX+4 = MSB of the Cursor Position, IX+5 = Cursor Character, IX+6 = “D”, and IX+7=”O”

According to the original ROM notes, this is the Display Driver. On exit, Register A to hold the character read from the new cursor position (if the routine was called to look for that). On entry, [IX] should point to the DCB, which is laid out as follows:

• DCB + 0 = DCB Type
• DCB + 1 = Driver Address (LSB)
• DCB + 2 = Driver Addres (MSB)
• DCB + 3 = Cursor Position Address (LSB)
• DCB + 4 = Cursor Position Address (MSB)
• DCB + 5 = Cursor Character
• DCB + 6 = “D”
• DCB + 7 = “O”

This is a space saver because if the cursor isn’t on the same line it needs to move down, so jumping here is also jumping to a CURSOR DOWN routine that was simply a fall-through from a wrap around

Same trick as dealing with CURSOR DOWN if there was an overflow, this does a CURSOR UP if you back up too far

Output the character held in Register A and move the cursor, scrolling the screen if necessary

Scroll the screen upward by one line

Display a carriage return / line feed

Erase to the end of the line

Erase to the end of the frame

To use a ROM call to clear the video screen from (including) position N – where N is an integer between 0 and 1023 (decimal), inclusive, to the end of the display, Load the HL Register with the value 3C00H + N and then CALL 057CH

According to the original ROM notes, this is the Printer Driver. On entry, Register C to hold the character to be sent to the printer, and [IX] should point to the DCB, which is laid out as follows:

• DCB + 0 = DCB Type
• DCB + 1 = Driver Address (LSB)
• DCB + 2 = Driver Addres (MSB)
• DCB + 3 = Lines Per Page (or 0 if top-of-page)
• DCB + 4 = Line Counter
• DCB + 5 = 0
• DCB + 6 = “P”
• DCB + 7 = “R”

A call to 05D1 will return the status of the line printer in the status Register As 0 if the printer is ready/selected, and non-zero if not ready, as follows:

• Bit 7 = Printer Busy. 1=Busy
• Bit 6 = Paper Status. 1= Out of paper.
• Bit 5 = Printer Ready. 1 = Ready.
• All other bits are not used.

This is the most basic of the string input routines and is used by the two others (1BB3H and 0361H) as a subroutine. To use it, load HL with the required buffer address and the B Register with the maximum buffer length required. Keyboard input over the specified maximum buffer length is ignored, and after pressing the (ENTER) key it will return with HL containing the original buffer address and B with the string length.

A call to this memory location Accepts keyboard input and stores each character in a buffer supplied by caller. Input continues until either a carriage return or a BREAK is typed, or until the buffer is full. All edit control codes are recognized, e.g. TAB, BACKSPACE, etc.

On exit the registers contain: HL=Buffer address, B=Number of characters transmitted excluding last, C=Orginal buffer size, A=Last character received if a carriage return or BREAK is typed. Carry Set if break key was terminator, reset otherwise. If the buffer is full, the A Register will contain the buffer size.

Accepts keyboard input and stores each character in a buffer supplied by caller. Input continues until either a carriage return or a BREAK is typed, or until the buffer is full. All edit control codes are recognized, e.g. TAB, BACKSPACE, etc

To use a ROM call to accept a restricted number of keyboard characters for input (n), use:
LD HL,(40A7H)
LD B,n
CALL 05D9H.

Up to n characters will be accepted, after which the keyboard will simply be ignored until the ENTER (or LEFT ARROW, or BREAK, or CLEAR) key is pressed. These characters will be stored in consecutive memory cells starting at the address contained in 40A7H-40A8H (the keyboard buffer area), with a 0DH (carriage return) byte at the end. Upon completion, the HL Register Pair will contain the address of the first character of the stored input, and the B Register will contain the number of characters entered. NOTE: No “?” is displayed as a result of the execution of the above program. If the “?” display is desired to prompt the typing of the input, precede the above program segment with:
LD A,3FH
CALL 033AH
LD A,20H
CALL 033AH

According to the original ROM comments, on entry, HL to point to the input line address in RAM and Register B to hold the maximum number of input characters to fetch. On exit, Register A should hold the number of characters entered

Cancel the accumulated line

Backspace one character. On entry Register B to hold the number of characters received, and Register C to hold the size of the buffer

Turn on 32 Character Mode

Process a horizontal tab

Process a Carriage Return and Automatic Line Feed

Check for a manual override

This is an alternative re-entry point into BASIC. A JP 6CCH is often better than a jump to 1A19H as the latter sometimes does strange things to any resident BASIC program

The math routines in the Level II ROM are fairly complex because they have to be. The following is a brief-ish description of the overall intentions of the authors:

RAM Locations / Purpose

Floating Point Formula

• The sign is the first bit of the mantissa
• The mantissa is 24 bits long
• THe binary point is to the left of the MSB
• The manitssa is positive, with a one assumed to be where the sign bit is
• The sign of the exponent is the first bit of the exponent
• The exponent is stored in excess of 80H (i.e., it is a signed 8 bit number with 80H added to it)
• An exponent of zero means the number is zero, and all other bytes are ignored

In memory a number looks like this:

• Bits 17-24 of the mantissa
• Bits 9-16 of the mantissa
• The sign is in Bit 7
• Bits 2-8 of the mantassa are in bits 6-0
• The exponent is stored as a signed number + 80H
• Bit 1 of the mantissa is always a 1

Calling Math Routines

To call a ONE argument routine, the argument should be in the FAC

To call a TWO argument routine, the first argument should be in BCDE and the second argument should be in the FAC

Regardless of which is desired, the result will be in the FAC

ROM routines with a “S” point to two argument operations which have (HL) pointing to the first argument instead of it being in BCDE. “MOVERM” is called to get the argument into the registers.

ROM routines with a “T” assume that the first argument is on the stack. “POPR” is used to get the arguments into the registers. Note: Never CALL a “T” routine, the return address will be confused with a number.

Stack Usage

The to LO’s are pushed first, and then the HO and finally the sign. The lower byte of each part is in the lower memory address, so when the number ios POPed into the registers, the higher order byte will be in the higher order register of the register pair (i.e., B, D, and H).

Single-precision addition (ACCumulator=(HL)+ACC) involving a buffer pointed to by the HL Register Pair and ACCumulator (i.e., 4121H-4122H). This part of the program loads the BCDE registers with the value from the buffer, then passes control to 716H.

Single-precision subtraction (ACC=(HL)-ACC). This loads the BCDE registers with the value from (HL), then passes control to 713H.

Single-precision subtraction (ACCumulator=BCDE-ACCumulator). The routine actually inverts ACCumulator (i.e., 4121H-4122H) and adds it to the contents of the BCDE registers which, in effect, is a subtraction. The result will be stored in the ACCumulator (i.e., 4121H-4122H).

Single Precision Subtract: Subtracts the single precision value in (BC/DE) from the single precision value in the ACCumulator. The difference is left in the ACCumulator

Single-precision subtraction (ACC=BCDE-ACC). The routine actually inverts the ACC and adds it to the contents of the BCDE registers which, in effect, is a subtraction. The result will be stored in the arithmetic work area (ACC)

Note: If you wanted to subtract two single precision numbers, store the minuend in the BCDE registers and store the subtrahend in 4121H-4124H and then CALL 0713H. The result (in single precision format) is in 4121H-4124H in approximately 670 microseconds.

Single-precision addition (ACCumulator=BCDE+ACC). This routine adds two single-precision values and stores the result in the ACCumulator area.

Note: If you wanted to add 2 single precision numbers via a ROM call, store one input into BCDE (with the exponent in B and the LSB in E) and the other into 4121H-4124H, and then call 0716H. The single precision result will be in 4121H-4124H approximately 1.3 milliseconds later.

Single Precision Add: Add the single precision value in (BC/DE) to the single precision value in the ACCumulator. The sum is left in the ACCumulator

Single-precision addition (ACC=BCDE+ACC). This routine adds two singleprecision values and stores the result in the ACC area

Formula: FAC:=ARG+FAC

Routine ALTERS A,B,C,D,E,H,L

If INTFSF=1 the format of floating point numbers will be:

• Reg B – SIGN AND BITS 1-7 OF EXPONENT
• Reg C – Bit 8 of exponent ;and bits 2-8 of mantissa
• Reg D – Bits 9-16 of mantissa
• Reg E – Bits 17-24 of mantissa, and likewise for the ACCumulator format
• Note: The exponent for intel will be 7FH

This routine will subtract CDEB from ((HL)+0,1,2),0.

This is a subroutine within the ROUND round. This will add one to C/D/E.

This routine adds (HL+2),)(HL+1),(HL+0) to C,D,E. This is called by FADD and FOUT.

This routine negates the number in C/D/E/B. CALLd by FADD and QUINT. Alters everything except Register H.

This routine will shift the number in C/D/E right the number of times held in Register A. The general idea is to shift right 8 places as many times as is possible within the number of times in A, and then jump out to shift single bits once you can’t shift 8 at a time anymore. Alters everything except Register H.

This routine will shift the number in C/D/E right the number of times held in Register A, but one byte at a time.