Address Line Test by Tony Gonzalez
[Up to Source Code Repository]

The typical RAM test consists of reading and writing $AA and $55 to each memory location. This works well for finding bad RAM locations. However, it does not specifically find bad address lines. This simple method does just that.

This code is a bit long, but purposely so to demonstrate how the technique works. Calling the routine at WRTDATA writes an incremental number to fifteen RAM locations, with the address of each location unique to A0-A14.

The program then falls through to RAMTEST1, which checks the RAM locations corresponding to A0-A7. If successful, it then jumps to RAMTEST2 which checks A8-A14. Note that A15 is not explicitly tested. It's assumed that the routine is placed somewhere in ROM above the first 32K, so if the program executes correctly then A15 must be functioning by default.

If the program succeeds, SUCCESS will clear the test bytes and return to the calling program.

If the program fails to see the correct data at any point, it branches to FOUNDBAD which in turn jumps to the error handler FAILURE, and the number of the address line under test (Axx) is preserved in the X register.

          .ORG $E000

;WRTDATA: Fill fifteen memory locations with unique, incremental
;values, where each address uses a unique address line.
WRTDATA:  LDX #$0F
          STX $4000     ;$4000 = #$0F  (for test of A14)
          DEX
          STX $2000     ;$2000 = #$0E  (for test of A13)
          DEX
          STX $1000     ;$1000 = #$0D  (for test of A12)
          DEX
          STX $0800     ;$0800 = #$0C  (for test of A11)
          DEX
          STX $0400     ;$0400 = #$0B  (for test of A10)
          DEX
          STX $0200     ;$0200 = #$0A  (for test of A9)
          DEX
          STX $0100     ;$0100 = #$09  (for test of A8)
          DEX
          STX $0080     ;$0080 = #$08  (for test of A7)
          DEX
          STX $0040     ;$0040 = #$07  (for test of A6)
          DEX
          STX $0020     ;$0020 = #$06  (for test of A5)
          DEX
          STX $0010     ;$0010 = #$05  (for test of A4)
          DEX
          STX $0008     ;$0008 = #$04  (for test of A3)
          DEX
          STX $0004     ;$0004 = #$03  (for test of A2)
          DEX
          STX $0002     ;$0002 = #$02  (for test of A1)
          DEX
          STX $0001     ;$0001 = #$01  (for test of A0)

;RAMTEST1: Check address lines A0-A7.
;Routine is broken into RAMTEST1 and RAMTEST2 due to the limited range
;of the relative branch instruction BNE.
RAMTEST1: CPX $0001
          BNE FOUNDBAD  ;A0 bad (not = #$01)?
          INX
          CPX $0002
          BNE FOUNDBAD  ;A1 bad (not = #$02)?
          INX
          CPX $0004
          BNE FOUNDBAD  ;A2 bad (not = #$03)?
          INX
          CPX $0008
          BNE FOUNDBAD  ;A3 bad (not = #$04)?
          INX
          CPX $0010
          BNE FOUNDBAD  ;A4 bad (not = #$05)?
          INX
          CPX $0020
          BNE FOUNDBAD  ;A5 bad (not = #$06)?
          INX
          CPX $0040
          BNE FOUNDBAD  ;A6 bad (not = #$07)?
          INX
          CPX $0080     ;A7 bad (not = #$08)?
          BNE FOUNDBAD
          JMP RAMTEST2

;FOUNDBAD: Called by either RAMTEST1 or RAMTEST2 if
;an error was detected.  This is the jump to the error handler.
FOUNDBAD: JMP FAILURE

;RAMTEST2: Tests address lines A8-A14
RAMTEST2: INX
          CPX $0100
          BNE FOUNDBAD  ;A8 bad (not = #$09)?
          INX
          CPX $0200
          BNE FOUNDBAD  ;A9 bad (not = #$0A)?
          INX
          CPX $0400
          BNE FOUNDBAD  ;A10 bad (not = #$0B)?
          INX
          CPX $0800
          BNE FOUNDBAD  ;A11 bad (not = #$0C)?
          INX
          CPX $1000
          BNE FOUNDBAD  ;A12 bad (not = #$0D)?
          INX
          CPX $2000
          BNE FOUNDBAD  ;A13 bad (not = #$0E)?
          INX
          CPX $4000
          BNE FOUNDBAD  ;A14 bad (not = #$0E)?

;SUCCESS: Program completed with no errors detected.
;
SUCCESS:  LDX #$00      ;Optional: Clean up the test bytes by filling
          STX $01       ;with #$00.
          STX $02
          STX $04
          STX $08
          STX $10
          STX $20
          STX $40
          STX $80
          STX $0100
          STX $0200
          STX $0400
          STX $0800
          STX $1000
          STX $2000
          STX $4000
          RTS

FAILURE:  DEX           ;An error was detected.
;	   .
;	   .            The address line under test (Axx) at the
;	   .            time of failure is in the X register.

Last page update: April 4, 2004.