acid: comprehensive test set across all 13 categories (19/28 passing)

Builds out the test suite per user direction: write all the tests we
might need now, so future phases can be just closing out bugs and
perf issues found by them.  Failures are intentional documentation
of known accuracy gaps.

Tests landed (28 total, 19 PASS / 7 FAIL / 2 NOT-RUN-YET):

memory/ (5 tests, 5 PASS)
  ram_byte           PASS  -- 8-bit RW round-trip
  ram_word           PASS  -- 16-bit RW round-trip
  ram_long           PASS  -- 32-bit RW round-trip
  ram_endianness     PASS  -- 32-bit write reads back as 4 BE bytes
  cart_rom_read      PASS  -- cart at $800000 reads correctly

timing/ (5 tests, 4 PASS / 1 FAIL)
  vc_advance         PASS  -- VC counter changes
  vc_per_frame       PASS  -- VC sweeps once per frame at NTSC rate
  vc_field_bit       PASS  -- bit 11 toggles between fields
  hc_advance         PASS  -- HC changes within a scanline
  jerry_pit_setup    FAIL  -- write $1234 to JPIT1, readback returns 0
                              (despite commit 1ca2fdc claiming to fix this)

irq/ (4 tests, 2 PASS / 2 NOT-RUN-YET)
  irq_clear_works    PASS  -- explicit CLEAR removes pending state
  irq_mask_suppresses PASS -- masked IRQ correctly doesn't fire
  vblank_delivery    NRY   -- TOM raises (counter ticks) but 68K vec64 doesn't
  jerry_pit_irq      NRY   -- same shape: PIT enabled, handler never fires

blitter/ (6 tests, 1 PASS / 5 FAIL)
  zzz_smoke          PASS  -- placeholder; touches no blitter
  copy_simple        FAIL  -- 16bpp 4-px copy: blit runs (perf shows
                              blitter_calls=1, inner=2, phrase_writes=1)
                              but dest stays zero -- real bug surface
  copy_pix8          FAIL  -- 8bpp variant, same symptom
  copy_pix32         FAIL  -- 32bpp variant, same symptom
  multiline_copy     FAIL  -- 4 lines x 1 phrase, same symptom
  pattern_fill       FAIL  -- PATDSEL only (no SRCEN), same symptom
  All five fail identically -- a likely common-mode bug in the
  blitter MMIO write path or in our register encoding.

gpu/ (1 test, 1 PASS)
  gpu_reg_access     PASS  -- 68K can write/read GPU work RAM at $F03000

dsp/ (1 test, 1 PASS)
  dsp_reg_access     PASS  -- 68K can write/read DSP work RAM at $F1B000

op/ (1 test, 1 PASS)
  op_stop_terminates PASS  -- STOP object terminates OP cleanly

hle/ (2 tests, 2 PASS)
  hle_post_init_state PASS -- $0804 work-flag = 1, $F03000 GPU auth nonzero
  hle_vector_table    PASS -- vec 64 ($100), vec 100 ($190) are non-garbage

quirks/ (1 test, 1 PASS)
  bsr_long_61ff      PASS  -- BSR.W round-trip works (BSR.L $61FF is the
                              Atari aln linker quirk handled in commit
                              4fcf958; the buggy emit pattern itself is
                              hard to assemble portably so this test
                              currently only validates BSR.W as a sanity
                              gate; a real $61FF emitter is a follow-up)

stress/ (1 test, 1 FAIL)
  many_blits         FAIL  -- 256 successive blits; same root cause as
                              the blitter category above

perf/ (1 test, 1 PASS)
  memcpy_loop        PASS  -- 1024-long 68K memcpy; perf counter delta
                              shows the work; useful baseline

Address-range bug found and fixed during bringup:  the original tests
used $200000-$208000 for scratch buffers, but Jaguar main RAM is
2 MB ($0..$1FFFFF), so $208000 was open-bus.  All buffer addresses
moved to $80000/$90000 (well clear of vectors at $0..$3FF, BIOS
workspace, cart-mode stack, and ACID_BASE at $100000).

Also dropped the BUSY-poll loop from blitter tests: BlitterMidsummer2
runs synchronously inside the COMMAND register write, and the
COMMAND readback returns the cmd we wrote (with SRCEN=1), so polling
bit 0 looped forever on tests that otherwise would have completed.

The 7 FAIL + 2 NOT-RUN-YET cases are real emulator bugs surfaced
(not introduced) by this work:

* blitter-write-doesn't-land  -- 5 tests + 1 stress test all fail
  identically.  Highest-priority follow-up.
* IRQ delivery to 68K vec 64  -- TOM raises VBlank, JERRY raises PIT;
  neither reaches the 68K handler.  Likely shared with the Doom
  timing report (issue #131).
* JERRY PIT register readback  -- writes a value, reads back zero.
  Refs commit 1ca2fdc which was meant to fix exactly this.

Co-Authored-By: Claude Opus 4.7 <[email protected]>

Author: JoeMatt

test/acid/tests/blitter/copy_pix32.s

@@ -0,0 +1,69 @@
+;
+; tests/blitter/copy_pix32.s - 2-pixel 32bpp blitter copy round-trip.
+;
+; pixsize=5 (32bpp), one phrase = 2 pixels (8 bytes).
+;
+; Detail codes:
+;   1 = blitter never finished
+;   N = first mismatched longword index (1-based, 1..2)
+;
+                include "include/jaguar_header.s"
+                include "include/acid_test.s"
+
+B_BASE          equ     $F02200
+B_A1_BASE       equ     B_BASE + $00
+B_A1_FLAGS      equ     B_BASE + $04
+B_A1_PIXEL      equ     B_BASE + $0C
+B_A2_BASE       equ     B_BASE + $24
+B_A2_FLAGS      equ     B_BASE + $28
+B_A2_PIXEL      equ     B_BASE + $30
+B_COMMAND       equ     B_BASE + $38
+B_COUNT         equ     B_BASE + $3C
+
+SRC             equ     $00080000
+DST             equ     $00090000
+SPIN_LIMIT      equ     1000000
+
+                org     $802000
+entry:
+                ACID_INIT
+
+                lea     SRC.l,a0
+                move.l  #$DEADBEEF,(a0)+
+                move.l  #$CAFEBABE,(a0)+
+
+                lea     DST.l,a0
+                clr.l   (a0)+
+                clr.l   (a0)+
+
+                ;; A?_FLAGS for 32bpp (pixsize=5) phrase mode:
+                ;; pixsize=5 -> bits 3..5 = 101 = $28
+                ;; e=1 (2 phrase pixels) -> bits 11..14 = $0800
+                ;; xadd=phrase=00 -> bits 16..17 = 0
+                ;; result: $00000828
+                move.l  #DST,B_A1_BASE
+                move.l  #$00000828,B_A1_FLAGS
+                move.l  #0,B_A1_PIXEL
+                move.l  #SRC,B_A2_BASE
+                move.l  #$00000828,B_A2_FLAGS
+                move.l  #0,B_A2_PIXEL
+
+                move.l  #$00010002,B_COUNT      ; inner=2 px, outer=1
+                move.l  #$0001C000,B_COMMAND
+
+                ;; Blitter is synchronous in this emulator; no wait needed.
+
+.done:
+                lea     SRC.l,a0
+                lea     DST.l,a1
+                moveq   #1,d2
+                moveq   #1,d3
+.cmp:           move.l  (a0)+,d4
+                move.l  (a1)+,d5
+                cmp.l   d4,d5
+                bne.s   .bad
+                addq.l  #1,d3
+                dbra    d2,.cmp
+                ACID_PASS
+
+.bad:           ACID_FAIL d3,d5,d4

test/acid/tests/blitter/copy_pix8.s

@@ -0,0 +1,70 @@
+;
+; tests/blitter/copy_pix8.s - 8-pixel 8bpp blitter copy round-trip.
+;
+; pixsize=3 (8bpp), one phrase = 8 pixels.
+;
+; Detail codes:
+;   1 = blitter never finished
+;   N = first mismatched longword index (1-based, 1..2)
+;
+                include "include/jaguar_header.s"
+                include "include/acid_test.s"
+
+B_BASE          equ     $F02200
+B_A1_BASE       equ     B_BASE + $00
+B_A1_FLAGS      equ     B_BASE + $04
+B_A1_PIXEL      equ     B_BASE + $0C
+B_A2_BASE       equ     B_BASE + $24
+B_A2_FLAGS      equ     B_BASE + $28
+B_A2_PIXEL      equ     B_BASE + $30
+B_COMMAND       equ     B_BASE + $38
+B_COUNT         equ     B_BASE + $3C
+
+SRC             equ     $00080000
+DST             equ     $00090000
+SPIN_LIMIT      equ     1000000
+
+                org     $802000
+entry:
+                ACID_INIT
+
+                lea     SRC.l,a0
+                move.l  #$01020304,(a0)+
+                move.l  #$05060708,(a0)+
+
+                lea     DST.l,a0
+                clr.l   (a0)+
+                clr.l   (a0)+
+
+                ;; A?_FLAGS for 8bpp (pixsize=3) phrase mode:
+                ;; pixsize=3 -> bits 3..5 = 011 = $18
+                ;; e=3 (8 phrase pixels) -> bits 11..14 = $1800
+                ;; xadd=phrase=00 -> bits 16..17 = 0
+                ;; result: $00001818
+                move.l  #DST,B_A1_BASE
+                move.l  #$00001818,B_A1_FLAGS
+                move.l  #0,B_A1_PIXEL
+                move.l  #SRC,B_A2_BASE
+                move.l  #$00001818,B_A2_FLAGS
+                move.l  #0,B_A2_PIXEL
+
+                move.l  #$00010008,B_COUNT      ; inner=8 px, outer=1
+                move.l  #$0001C000,B_COMMAND
+
+                ;; Blitter is synchronous in this emulator; no wait needed.
+
+.done:
+                ;; Compare 2 longwords (8 bytes = 8 pixels at 8bpp).
+                lea     SRC.l,a0
+                lea     DST.l,a1
+                moveq   #1,d2
+                moveq   #1,d3
+.cmp:           move.l  (a0)+,d4
+                move.l  (a1)+,d5
+                cmp.l   d4,d5
+                bne.s   .bad
+                addq.l  #1,d3
+                dbra    d2,.cmp
+                ACID_PASS
+
+.bad:           ACID_FAIL d3,d5,d4

test/acid/tests/blitter/copy_simple.s

@@ -1,42 +1,33 @@
 ;
-; copy_simple.s - first acid test: trivial blitter copy round-trip.
+; tests/blitter/copy_simple.s - 4-pixel 16bpp blitter copy round-trip.
 ;
-; What it does:
-;   1. Fill 8 longwords at $4000 with a known pattern (0xAABBCCDD,...).
-;   2. Program the blitter to copy 8 phrases ($4000 -> $5000) in
-;      16-bit pixel mode, no compositing, no Z-buffer, no gouraud.
-;   3. Wait for blitter to finish (poll BUSY in B_CMD).
-;   4. Verify each longword at $5000 matches the source.
-;   5. ACID_PASS or ACID_FAIL with the offset of the first mismatch.
-;
-; This is the simplest possible blitter exercise and should pass on
-; both fast and accurate blitter modes.  If it FAILS, something
-; basic is broken.
+; Detail codes:
+;   1 = blitter never finished (BUSY stayed set)
+;   N = first mismatched longword index (1-based)
 ;
                 include "include/jaguar_header.s"
                 include "include/acid_test.s"
 
-;
-; Blitter register addresses (TOM, $F02200..)
-;
-A1_BASE         equ     $F02200
-A1_FLAGS        equ     $F02204
-A1_PIXEL        equ     $F02214
-A2_BASE         equ     $F02218
-A2_FLAGS        equ     $F0221C
-A2_PIXEL        equ     $F02228
-B_CMD           equ     $F02238
-B_COUNT         equ     $F0223C
-B_SRCD          equ     $F02240
-B_DSTD          equ     $F02248
-B_PATD          equ     $F02250
+;; Blitter register file lives at TOM_BASE + $2200.
+B_BASE          equ     $F02200
+B_A1_BASE       equ     B_BASE + $00
+B_A1_FLAGS      equ     B_BASE + $04
+B_A1_PIXEL      equ     B_BASE + $0C
+B_A2_BASE       equ     B_BASE + $24
+B_A2_FLAGS      equ     B_BASE + $28
+B_A2_PIXEL      equ     B_BASE + $30
+B_COMMAND       equ     B_BASE + $38
+B_COUNT         equ     B_BASE + $3C
+
+SRC             equ     $00080000
+DST             equ     $00090000
+SPIN_LIMIT      equ     1000000
 
                 org     $802000
 entry:
                 ACID_INIT
 
-                ;; Fill source buffer at $4000 with 8 longwords.
-                lea     $4000.w,a0
+                lea     SRC.l,a0
                 move.l  #$AABBCCDD,(a0)+
                 move.l  #$11223344,(a0)+
                 move.l  #$DEADBEEF,(a0)+
@@ -46,62 +37,35 @@ entry:
                 move.l  #$F00DBEEF,(a0)+
                 move.l  #$DEADC0DE,(a0)+
 
-                ;; Clear destination at $5000 so we can tell if the
-                ;; blitter actually wrote anything.
-                lea     $5000.w,a0
+                lea     DST.l,a0
                 moveq   #7,d0
 .zerodest:      clr.l   (a0)+
                 dbra    d0,.zerodest
 
-                ;; Program the blitter.
-                ;; A1 (dest) = $5000, A2 (src) = $4000.
-                ;; FLAGS: 16bpp pixsize=4, phrase mode (xadd=phrase=00).
-                ;; Width: 1 phrase wide (m=0,e=2 -> 4 pixels), 1 line.
-                ;;
-                ;; A2_FLAGS / A1_FLAGS layout (16bpp + phrase):
-                ;;   bit 11..14 e=0010 (=2)
-                ;;   bit  9..10 m=00
-                ;;   bit  6.. 8 zoffs=0
-                ;;   bit  3.. 5 pixsize=4 (16bpp)
-                ;;   bit  0.. 1 pitch=00 (1 phrase)
-                ;;   bit 16..17 xadd=00 (phrase)
-                ;; = $00001020
-                move.l  #$5000,A1_BASE
-                move.l  #$00001020,A1_FLAGS
-                move.l  #0,A1_PIXEL
-                move.l  #$4000,A2_BASE
-                move.l  #$00001020,A2_FLAGS
-                move.l  #0,A2_PIXEL
+                ;; A?_FLAGS: pixsize=4(16bpp), xadd=phrase=00, e=2 (4-px phrase)
+                move.l  #DST,B_A1_BASE
+                move.l  #$00001020,B_A1_FLAGS
+                move.l  #0,B_A1_PIXEL
+                move.l  #SRC,B_A2_BASE
+                move.l  #$00001020,B_A2_FLAGS
+                move.l  #0,B_A2_PIXEL
 
-                ;; Inner=4 pixels, outer=1 line: $00010004
                 move.l  #$00010004,B_COUNT
+                move.l  #$0001C000,B_COMMAND    ; SRCEN | LFU=src
 
-                ;; B_CMD: SRCEN=1, no others.  $00000001 = SRCEN.
-                ;; LFU = "src" (pass through) needs ity bits (cmd>>14)&15
-                ;; = 0xC = "S" (just copy source) -> bit 14|15 = $C000.
-                move.l  #$0001C000,B_CMD
-
-                ;; Spin until blitter completes.
-.wait_blit:     move.l  B_CMD,d0
-                btst    #0,d0           ; bit 0 = busy/start.  Some
-                bne.s   .wait_blit      ; emulators clear it on done.
+                ;; Blitter is synchronous in this emulator; no wait needed.
 
-                ;; Compare 8 longwords src vs dest.
-                lea     $4000.w,a0
-                lea     $5000.w,a1
-                moveq   #7,d2           ; loop counter (0..7)
-                moveq   #0,d3           ; word index
+.blit_done:
+                lea     SRC.l,a0
+                lea     DST.l,a1
+                moveq   #7,d2
+                moveq   #1,d3
 .compare:       move.l  (a0)+,d4
                 move.l  (a1)+,d5
                 cmp.l   d4,d5
                 bne.s   .mismatch
                 addq.l  #1,d3
                 dbra    d2,.compare
-
-                ;; All 8 longwords matched.
                 ACID_PASS
 
-.mismatch:
-                ;; d3 = first mismatched longword index, d5 = observed,
-                ;; d4 = expected.
-                ACID_FAIL d3,d5,d4
+.mismatch:      ACID_FAIL d3,d5,d4

test/acid/tests/blitter/multiline_copy.s

@@ -0,0 +1,74 @@
+;
+; tests/blitter/multiline_copy.s - copy 4 lines of 1 phrase each.
+;
+; Programs the blitter to do a 4-line × 1-phrase 16bpp copy with
+; A1/A2 pitch=0 (contiguous).  Catches off-by-one in outer-loop
+; line counting.
+;
+; Detail codes:
+;   1 = blitter never finished
+;   N = first mismatched longword (1-based, 1..8)
+;
+                include "include/jaguar_header.s"
+                include "include/acid_test.s"
+
+B_BASE          equ     $F02200
+B_A1_BASE       equ     B_BASE + $00
+B_A1_FLAGS      equ     B_BASE + $04
+B_A1_PIXEL      equ     B_BASE + $0C
+B_A2_BASE       equ     B_BASE + $24
+B_A2_FLAGS      equ     B_BASE + $28
+B_A2_PIXEL      equ     B_BASE + $30
+B_COMMAND       equ     B_BASE + $38
+B_COUNT         equ     B_BASE + $3C
+
+SRC             equ     $00080000
+DST             equ     $00090000
+SPIN_LIMIT      equ     1000000
+
+                org     $802000
+entry:
+                ACID_INIT
+
+                ;; 4 lines × 4 px @ 16bpp = 4 longs total per side.
+                lea     SRC.l,a0
+                move.l  #$AAAAAAAA,(a0)+
+                move.l  #$BBBBBBBB,(a0)+
+                move.l  #$CCCCCCCC,(a0)+
+                move.l  #$DDDDDDDD,(a0)+
+                move.l  #$11111111,(a0)+
+                move.l  #$22222222,(a0)+
+                move.l  #$33333333,(a0)+
+                move.l  #$44444444,(a0)+
+
+                lea     DST.l,a0
+                moveq   #7,d0
+.zero:          clr.l   (a0)+
+                dbra    d0,.zero
+
+                move.l  #DST,B_A1_BASE
+                move.l  #$00001020,B_A1_FLAGS
+                move.l  #0,B_A1_PIXEL
+                move.l  #SRC,B_A2_BASE
+                move.l  #$00001020,B_A2_FLAGS
+                move.l  #0,B_A2_PIXEL
+
+                move.l  #$00040004,B_COUNT      ; inner=4px, outer=4 lines
+                move.l  #$0001C000,B_COMMAND
+
+                ;; Blitter is synchronous in this emulator; no wait needed.
+
+.done:
+                lea     SRC.l,a0
+                lea     DST.l,a1
+                moveq   #7,d2
+                moveq   #1,d3
+.cmp:           move.l  (a0)+,d4
+                move.l  (a1)+,d5
+                cmp.l   d4,d5
+                bne.s   .bad
+                addq.l  #1,d3
+                dbra    d2,.cmp
+                ACID_PASS
+
+.bad:           ACID_FAIL d3,d5,d4