Dragon-s-Lair-X68k/tools/bench/dma.lua

-- Drive src/player/dmagate.s: does the HD63450 drive the SCSI data phase, and
-- does it HOLD THE BUS?  (ROADMAP P4a)
--
-- THE APPARATUS is tools/bench/scsi_run.sh's, unchanged and stated again
-- because it is two substitutions deep: `x68000 -exp1 cz6bs1` (the board 42.5
-- says to benchmark, never x68ksupr, whose internal SCSI is PIO-only in MAME),
-- and a ZERO-FILLED scsiexrom.bin on a private rompath, which is honest only
-- because the player drives the SPC registers directly and never executes a
-- byte of that ROM.
--
-- WHAT THIS RIG DOES NOT DO, and it is the point of the whole design: it never
-- looks at $EA0015.  57.3 showed that address cannot answer the question --
-- with the DMAC's OWN asserted MAME cannot tell a CPU-driven byte there from a
-- DMAC-driven one.  What separates the two configurations below is whether the
-- 68000 EXECUTED ANYTHING while the bytes were arriving, which is a fact about
-- the CPU and is read out of the DMAC's own registers plus a counter the
-- machine incremented itself.
--
-- AND IT IS NOT A RATE.  MAME's DMAC is configured in wall-clock attotimes
-- (42.5); its burst mode halts the CPU outright rather than charging it cycles
-- per operand.  `W` is untouched here and still wants a board.
local M  = manager.machine
local SP = M.devices[":maincpu"].spaces["program"]
local function P(s) print("[DMA] "..s) end
local function T() local t=M.time; return t.seconds + t.attoseconds/1e18 end

local DGFLAG, DGREC, DGREC_SZ = 0x18600, 0x18610, 32
local DGWIN, DGWERR = 0x18680, 0x18684
local DGLBA, DGBLK  = 1000, 4
local DST = {0x20000, 0x24000, 0x28000}
local NAME = {"PIO            (the path FINDINGS 58 measured)",
              "DMA, BUS HELD  (DCR $00 burst, OCR $81 max rate)",
              "DMA, STEALING  (DCR $80 cycle steal, OCR $80 limited)"}
local SHORT = {"pio", "held", "steal"}
local ERRNAME = {[0]="OK", "SELECTION TIMEOUT -- no target answered",
                 "UNEXPECTED PHASE", "POLL TIMEOUT -- a phase never arrived",
                 "NON-ZERO SCSI STATUS",
                 "WINDOWED READ REFUSED -- a channel cannot drop bytes"}
local DISK = os.getenv("DLX_SCSI_IMG") or "dlxdisk.img"

local code do local f=io.open("dmagate.bin","rb"); code=f:read("a"); f:close() end

-- the disc's own bytes, once, for all three comparisons
local want do
  local f = io.open(DISK, "rb")
  if f then f:seek("set", DGLBA*512); want = f:read(DGBLK*512); f:close() end
end

local st = "boot"
SUB = emu.add_machine_frame_notifier(function()
  local ok, err = pcall(function()
    if st == "boot" then
      if T() < 3.0 then return end
      for i = 1, #code do SP:write_u8(0x10000+i-1, string.byte(code,i)) end
      SP:write_u32(DGFLAG, 0)
      local cpu = M.devices[":maincpu"]
      cpu.state["SR"].value = 0x2700
      cpu.state["SP"].value = 0x8000
      cpu.state["PC"].value = 0x10000
      P(string.format("dmagate.bin=%d B loaded at $10000; reading LBA %d, %d B, "
                      .."three ways", #code, DGLBA, DGBLK*512))
      st = "wait"; return
    end
    if st == "wait" then
      if SP:read_u32(DGFLAG) ~= 1 then
        if T() > 60 then P("TIMEOUT: the gate never finished"); P("done"); M:exit() end
        return
      end
      if not want then P("no "..DISK.." to check against"); P("done"); M:exit(); return end
      local LEN = DGBLK*512
      for i = 0, 2 do
        local b = DGREC + i*DGREC_SZ
        local rc   = SP:read_u32(b)
        local e    = SP:read_u32(b+4)
        local mtc0 = SP:read_u32(b+8)
        local spin = SP:read_u32(b+12)
        local csr  = SP:read_u32(b+16)
        local cer  = SP:read_u32(b+20)
        local mtcf = SP:read_u32(b+24)
        local marf = SP:read_u32(b+28)
        P(NAME[i+1])
        if rc ~= 0 then
          P(string.format("  FAILED: err=%d (%s)", e, ERRNAME[e] or "?"))
        else
          local bad, first = 0, nil
          for k = 1, LEN do
            if SP:read_u8(DST[i+1]+k-1) ~= string.byte(want, k) then
              bad = bad + 1; first = first or (k-1)
            end
          end
          if bad == 0 then
            P(string.format("  BYTES OK: %d B from LBA %d match %s byte for byte "
                            .."[%s]", LEN, DGLBA, DISK, SHORT[i+1]))
          else
            P(string.format("  BYTES WRONG [%s]: %d of %d differ, first at +%d",
                            SHORT[i+1], bad, LEN, first))
          end
        end
        if i > 0 then
          -- THE DISCRIMINATOR.  MTC as the instruction after START saw it, and
          -- the number of times the CPU went round its own wait loop.
          P(string.format("  MTC one instruction after START: %d of %d  -> the "
                          .."CPU %s while the transfer ran [%s]",
                          mtc0, LEN,
                          (mtc0 == 0) and "NEVER EXECUTED" or "kept executing",
                          SHORT[i+1]))
          P(string.format("  CPU trips round the wait loop: %d [%s]", spin, SHORT[i+1]))
          P(string.format("  channel: CSR=$%02X (%s%s%s) CER=$%02X MTC=%d "
                          .."MAR=$%06X (+%d) [%s]",
                          csr,
                          ((csr & 0x80) ~= 0) and "COC " or "",
                          ((csr & 0x10) ~= 0) and "ERR " or "",
                          ((csr & 0x08) ~= 0) and "ACT" or "idle",
                          cer, mtcf, marf, marf - DST[i+1], SHORT[i+1]))
        end
      end
      -- The refusal.  Expected to fail, and the run is only green if it did.
      local w, we = SP:read_u32(DGWIN), SP:read_u32(DGWERR)
      if w == 0xFFFFFFFF and we == 5 then
        P("WINDOWED DMA READ REFUSED, as it must be: a channel writes a "
          .."contiguous run and cannot drop the 300 B in front of the record "
          .."(58.3). P4a's precondition is a SECTOR-ALIGNED container.")
      else
        P(string.format("WINDOW NOT REFUSED: rc=%d err=%d -- the transport would "
                        .."have written the neighbours' bytes into the ring.", w, we))
      end
      P("done"); M:exit(); return
    end
  end)
  if not ok then P("LUA ERROR: "..tostring(err)); P("done"); M:exit() end
end)