badline 0.12.1 → 0.14.0

data/lib/badline/c64/reu/dma.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class REU
+      # One transfer between the C64 and the REU's RAM, clocked a cycle at a
+      # time while the REC holds the bus. The REC only reads the C64's bus
+      # while BA is high, so a read followed by BA low waits for BA to rise.
+      # After a write it goes on through the first BA-low cycle and stops at
+      # the second. See doc/pinned-behaviour.md, REU DMA.
+      class DMA
+        # Transfer types, as the command register's bottom two bits give
+        # them.
+        STASH = 0
+        FETCH = 1
+        SWAP = 2
+        VERIFY = 3
+
+        # What the REC did on the cycle before.
+        IDLE = 0
+        READ = 1
+        WRITE = 2
+
+        # Where the transfer stopped, what it left for the length register,
+        # and the status bits it ended with.
+        attr_reader :c64, :expansion, :length, :events
+
+        def initialize(ram, span, bus)
+          @ram = ram
+          @span = span
+          @bus = bus
+          @c64 = @expansion = @length = @events = 0
+          @holding = false
+        end
+
+        # Whether the REC held the bus on the last cycle clocked, which it
+        # does while it waits for BA too, since the CPU stays halted.
+        def holds_bus? = @holding
+
+        # A length of 0 moves 64K. control is the address control register,
+        # which can hold either address where it is.
+        def start(type, c64, expansion, length, control)
+          @type = type
+          @c64 = c64
+          @expansion = expansion
+          @length = length.zero? ? 0x10000 : length
+          @c64_step = control.anybits?(FIX_C64) ? 0 : 1
+          @expansion_step = control.anybits?(FIX_EXPANSION) ? 0 : 1
+          @events = 0
+          @holding = true
+          @last = IDLE
+          @waiting = false
+          @ba_low_after_writes = 0
+          @stopped_after_write = false
+          @swap_write_due = false
+          @swap_read_again = false
+          @swap_byte = 0
+          @held_read = 0
+          @moved_all = false
+          @extra_cycle = false
+        end
+
+        # Writes the byte a fetch from these addresses starts with, without
+        # counting it. Other transfers start with a read.
+        def write_ahead(type, c64, expansion)
+          return unless type == FETCH
+
+          @c64 = c64
+          byte = @ram.peek(expansion)
+          @ram.latch = byte
+          write_c64(byte)
+        end
+
+        # One cycle of the transfer. The cycle the REC lets go of the bus on
+        # is the CPU's. late says BA fell on this cycle but a REC that moved a
+        # byte on the last one doesn't see it yet (VIC#reu_ba_late?), and
+        # handed_on that BA runs on from a bad line's DMA into a sprite's
+        # here (VIC#reu_ba_handed_on?).
+        def cycle!(ba_low, late, handed_on)
+          note_ba(ba_low, late)
+          @swap_read_again ||= handed_on && @swap_write_due
+          settle_held_read(ba_low) if @held_read.positive?
+          return if @waiting && ba_low
+
+          @waiting = false
+          @moved_all ? wind_down : move(ba_low)
+        end
+
+        private
+
+        # The second BA-low cycle in a row after writes stops the REC, and so
+        # does any BA-low cycle after a read. It then waits for BA to rise.
+        def note_ba(ba_low, late)
+          seen = ba_low && !late
+          if @last == READ
+            note_ba_after_read(seen)
+          elsif @last == WRITE
+            note_ba_after_write(seen)
+          end
+          @last = IDLE
+        end
+
+        # A swap's read that BA stops before its write is made again.
+        def note_ba_after_read(ba_low)
+          @waiting = ba_low
+          @ba_low_after_writes = 0
+          @swap_read_again = ba_low && @swap_write_due && @held_read.zero?
+        end
+
+        # A fetch's last write doesn't go through the first BA-low cycle.
+        # Pinned by REU/reutiming2/d and d2.
+        def note_ba_after_write(ba_low)
+          @ba_low_after_writes = ba_low ? @ba_low_after_writes + 1 : 0
+          @stopped_after_write = @ba_low_after_writes == 2 || (ba_low && @type == FETCH && @length == 1)
+          return unless @stopped_after_write
+
+          @waiting = true
+          @ba_low_after_writes = 0
+        end
+
+        # A fetch or a swap whose last write ran into BA, or a verify that
+        # found a difference before its last byte, takes one more cycle before
+        # the REC lets go of the bus.
+        def wind_down
+          if @extra_cycle || (@stopped_after_write && (@type == FETCH || @type == SWAP))
+            @extra_cycle = @stopped_after_write = false
+            @last = READ
+            return
+          end
+
+          @holding = false
+          settle
+        end
+
+        def move(ba_low)
+          case @type
+          when STASH then stash
+          when FETCH then fetch
+          when SWAP then swap(ba_low)
+          else verify
+          end
+        end
+
+        # The REU's data bus latch keeps the last byte the REC stored.
+        def stash
+          byte = read_c64
+          @ram.poke(@expansion, byte)
+          @ram.latch = byte
+          step
+          @last = READ
+        end
+
+        def fetch
+          byte = @ram.peek(@expansion)
+          @ram.latch = byte
+          write_c64(byte)
+          step
+          @last = WRITE
+        end
+
+        # Two cycles a byte: the C64's byte is read and stored while the
+        # REU's is fetched, and the REU's is written to the C64 on the next.
+        def swap(ba_low)
+          return read_swap_again if @swap_read_again
+
+          if @swap_write_due
+            @swap_write_due = false
+            write_c64(@swap_byte)
+            step
+            @last = WRITE
+            return
+          end
+
+          @swap_byte = @ram.peek(@expansion)
+          @swap_write_due = true
+          @last = READ
+          return swap_read_on_ba if ba_low
+
+          @ram.poke(@expansion, read_c64)
+        end
+
+        # A swap's read on the first BA-low cycle after a write, while AEC is
+        # still high. On the last byte the read is made there, the write
+        # follows on the next cycle whatever BA does, and the REC lets go.
+        # Otherwise the read stays open and takes what is on the bus two
+        # cycles later, or on the cycle BA rises if that comes first. Pinned
+        # by REU/reutiming2/e5-m2, f3-m2 and f4-m2.
+        def swap_read_on_ba
+          return @held_read = 2 unless @length == 1
+
+          @ram.poke(@expansion, read_c64)
+          @last = IDLE
+          @ba_low_after_writes = 0
+        end
+
+        # A swap's read that BA cut off from its write is made again when BA
+        # rises, and the write follows it. Pinned by REU/reutiming2/e4-m2,
+        # e6-m2 and g3-m2.
+        def read_swap_again
+          @swap_read_again = false
+          @ram.poke(@expansion, read_c64)
+          @last = READ
+        end
+
+        def settle_held_read(ba_low)
+          @held_read -= 1
+          return if @held_read.positive? && ba_low
+
+          @held_read = 0
+          @ram.poke(@expansion, read_c64)
+        end
+
+        # A difference ends the transfer, with one cycle more if bytes were
+        # left to compare.
+        def verify
+          same = @ram.peek(@expansion) == read_c64
+          step
+          @last = READ
+          return if same
+
+          @events |= FAULT
+          @extra_cycle = @length.positive?
+          @moved_all = true
+        end
+
+        # The REC reaches C64 memory as the CPU sees it, but at $00 and $01
+        # it reaches the RAM under the CPU's port.
+        def read_c64
+          @c64 < 0x02 ? @bus.ram.peek(@c64) : @bus.peek(@c64)
+        end
+
+        def write_c64(byte)
+          @c64 < 0x02 ? @bus.ram.poke(@c64, byte) : @bus.poke(@c64, byte)
+        end
+
+        # The REC counts the expansion address in its 19 low bits, from the
+        # top of its span back to 0, and leaves the bank bits above them as
+        # they were.
+        def step
+          @c64 = (@c64 + @c64_step) & 0xffff
+          low = (@expansion & 0x7ffff) + @expansion_step
+          @expansion = (@expansion & 0xf80000) | (low == @span ? 0 : low)
+          @length -= 1
+          @moved_all = true if @length.zero?
+        end
+
+        # The length register is left at 1 after a whole block. A fetch has
+        # already fetched the byte after its last into the latch.
+        def settle
+          return settle_verify if @type == VERIFY
+
+          @length += 1
+          @events |= END_OF_BLOCK
+          @ram.latch = @ram.peek(@expansion) if @type == FETCH
+        end
+
+        # A verify that compared every byte ends the block. One that found a
+        # difference on the byte before the last compares the last too, and
+        # ends the block if that one is the same.
+        def settle_verify
+          if @length.zero?
+            @length = 1
+            @events |= END_OF_BLOCK
+          elsif @length == 1 && @ram.peek(@expansion) == read_c64
+            @events |= END_OF_BLOCK
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/c64/reu/keyed_state.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class REU
+      class DMA
+        # The kinds of transfer, by name.
+        TYPE_NAMES = %w[stash fetch swap verify].freeze
+
+        # A transfer's fields in a keyed snapshot module, under `prefix`.
+        # Before the first transfer, the fields it sets on starting are
+        # absent.
+        module KeyedState
+          def save_fields(out, prefix)
+            out.int("#{prefix}c64", @c64).int("#{prefix}expansion", @expansion).int("#{prefix}length", @length)
+            out.int("#{prefix}events", @events)
+            type = @type
+            out.text("#{prefix}type", TYPE_NAMES.fetch(type)) unless type.nil?
+            out.optional_int("#{prefix}c64_step", @c64_step).optional_int("#{prefix}expansion_step", @expansion_step)
+            out.optional_int("#{prefix}last", @last).optional_int("#{prefix}ba_low_after_writes", @ba_low_after_writes)
+            out.optional_int("#{prefix}swap_byte", @swap_byte).optional_int("#{prefix}held_read", @held_read)
+            save_flag_fields(out, prefix)
+          end
+
+          def load_fields(input, prefix)
+            @c64 = input.word("#{prefix}c64", @c64)
+            @expansion = input.int("#{prefix}expansion", @expansion)
+            @length = input.int("#{prefix}length", @length)
+            @events = input.int("#{prefix}events", @events)
+            type = input.choice("#{prefix}type", TYPE_NAMES + ["none"], "none")
+            @type = type == "none" ? nil : TYPE_NAMES.index(type)
+            @c64_step = input.optional_int("#{prefix}c64_step")
+            @expansion_step = input.optional_int("#{prefix}expansion_step")
+            @last = input.optional_int("#{prefix}last")
+            @ba_low_after_writes = input.optional_int("#{prefix}ba_low_after_writes")
+            @swap_byte = input.optional_int("#{prefix}swap_byte")
+            @held_read = input.optional_int("#{prefix}held_read")
+            load_flag_fields(input, prefix)
+          end
+
+          private
+
+          def save_flag_fields(out, prefix)
+            out.bool("#{prefix}holding", @holding).bool("#{prefix}waiting", @waiting)
+            out.bool("#{prefix}stopped_after_write", @stopped_after_write)
+            out.bool("#{prefix}swap_write_due", @swap_write_due).bool("#{prefix}swap_read_again", @swap_read_again)
+            out.bool("#{prefix}moved_all", @moved_all).bool("#{prefix}extra_cycle", @extra_cycle)
+          end
+
+          def load_flag_fields(input, prefix)
+            @holding = input.bool("#{prefix}holding", @holding)
+            @waiting = input.bool("#{prefix}waiting", @waiting)
+            @stopped_after_write = input.bool("#{prefix}stopped_after_write", @stopped_after_write)
+            @swap_write_due = input.bool("#{prefix}swap_write_due", @swap_write_due)
+            @swap_read_again = input.bool("#{prefix}swap_read_again", @swap_read_again)
+            @moved_all = input.bool("#{prefix}moved_all", @moved_all)
+            @extra_cycle = input.bool("#{prefix}extra_cycle", @extra_cycle)
+          end
+        end
+
+        include KeyedState
+      end
+
+      class RAM
+        # The data latch and each bank the REC has touched, as bank<N>; a
+        # bank left out holds its power-on contents.
+        module KeyedState
+          def save_fields(out)
+            out.int("latch", @latch)
+            @banks.each_with_index { |bank, number| out.bytes("bank#{number}", bank) unless bank.empty? }
+          end
+
+          def load_fields(input)
+            @latch = input.byte("latch", @latch)
+            @banks.each_index do |number|
+              @banks[number] = input.bytes("bank#{number}", "".b).bytes
+            end
+          end
+        end
+
+        include KeyedState
+      end
+
+      # The REU's fields in a keyed snapshot module (Snapshot::Keyed): the
+      # REC's registers and the values its counters start from, an armed or
+      # running transfer, the transfer under dma.*, and the RAM. The IRQ
+      # line comes from the status register on load.
+      module KeyedState
+        # The REU's size in K, which the machine's setup names.
+        def size_kb = @size_kb
+
+        def save_fields(out)
+          out.int("status", @status).int("command", @command).int("c64", @c64).int("c64_start", @c64_start)
+          out.int("expansion", @expansion).int("expansion_start", @expansion_start).int("bank", @bank)
+          out.int("bank_start", @bank_start).int("length", @length).int("length_start", @length_start)
+          out.int("interrupt_mask", @interrupt_mask).int("address_control", @address_control)
+          out.bool("armed", @armed).bool("requested", @requested).bool("running", @running)
+          out.bool("ba_was_low", @ba_was_low)
+          @dma.save_fields(out, "dma.")
+          @ram.save_fields(out)
+          out
+        end
+
+        def load_fields(input)
+          load_register_fields(input)
+          @armed = input.bool("armed", @armed)
+          @requested = input.bool("requested", @requested)
+          @running = input.bool("running", @running)
+          @ba_was_low = input.bool("ba_was_low", @ba_was_low)
+          @dma.load_fields(input, "dma.")
+          @ram.load_fields(input)
+        end
+
+        # Without calling back into the machine, which reads the line again.
+        def restored!
+          @irq = @status.anybits?(INTERRUPT_PENDING)
+        end
+
+        private
+
+        def load_register_fields(input)
+          @status = input.byte("status", @status)
+          @command = input.byte("command", @command)
+          @c64 = input.word("c64", @c64)
+          @c64_start = input.word("c64_start", @c64_start)
+          @expansion = input.word("expansion", @expansion)
+          @expansion_start = input.word("expansion_start", @expansion_start)
+          @bank = input.byte("bank", @bank)
+          @bank_start = input.byte("bank_start", @bank_start)
+          @length = input.word("length", @length)
+          @length_start = input.word("length_start", @length_start)
+          @interrupt_mask = input.byte("interrupt_mask", @interrupt_mask)
+          @address_control = input.byte("address_control", @address_control)
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/c64/reu/ram.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class REU
+      # The REU's DRAM, as the REC addresses it. The REC counts 19 address
+      # bits, 17 on the 1700, and the 1764 fills only the first 256K of
+      # them: past that a read finds the latch on the REU's data bus, which
+      # holds the last byte the REC moved. A unit past 512K takes its upper
+      # address lines from the bank register.
+      class RAM
+        BANK_SIZE = 0x10000
+
+        # Where a bank of a 1764 that has just been switched on reads
+        # inverted, over the first 128K of each 256K. Over the second 128K
+        # it is the rest of the bank that reads inverted. Measured from
+        # REU/raminitpattern/dumpfile-256k-x1541.bin, a real 1764's dump.
+        INVERTED = [0x2a00...0x5400, 0x8000...0xac00, 0xd600...0x10000].freeze
+
+        attr_reader :size
+        attr_accessor :latch
+
+        def initialize(size, span)
+          @size = size
+          @mask = (size > 0x80000 ? size : span) - 1
+          @banks = Array.new(size / BANK_SIZE) { [] }
+          @power_on = [[], []]
+          @latch = 0xff
+        end
+
+        def peek(addr)
+          addr &= @mask
+          addr < @size ? bank(addr >> 16)[addr & 0xffff] : @latch
+        end
+
+        def poke(addr, value)
+          addr &= @mask
+          bank(addr >> 16)[addr & 0xffff] = value if addr < @size
+        end
+
+        # Every byte, as one string, with a bank the REC hasn't touched at
+        # its power-on contents.
+        def contents
+          power_on = power_on_strings
+          Array.new(@banks.length) do |number|
+            bank = @banks[number]
+            bank.empty? ? power_on[(number >> 1) & 1] : bank.pack("C*")
+          end.join
+        end
+
+        # Takes every byte from a string as long as the RAM. A bank that
+        # holds its power-on contents stays untouched.
+        def restore(bytes)
+          power_on = power_on_strings
+          @banks.each_index do |number|
+            slice = bytes.byteslice(number * BANK_SIZE, BANK_SIZE).to_s
+            @banks[number] = slice == power_on[(number >> 1) & 1] ? [] : slice.bytes
+          end
+        end
+
+        private
+
+        def power_on_strings
+          [0, 1].map do |half|
+            @power_on[half] = power_on_bank(half == 1) if @power_on[half].empty?
+            @power_on[half].pack("C*")
+          end
+        end
+
+        # A bank takes its power-on contents the first time it is touched,
+        # so an REU costs only the memory a program uses.
+        def bank(number)
+          bank = @banks[number]
+          return bank unless bank.empty?
+
+          half = (number >> 1) & 1
+          @power_on[half] = power_on_bank(half == 1) if @power_on[half].empty?
+          @banks[number] = @power_on[half].dup
+        end
+
+        # Pairs of $FF and $00 bytes, starting with a single $FF, and each
+        # odd page the inverse of the even one before it.
+        def power_on_bank(upper)
+          Array.new(BANK_SIZE) do |offset|
+            byte = (offset + 1).anybits?(2) ? 0x00 : 0xff
+            byte ^= 0xff if offset.anybits?(0x100)
+            inverted = INVERTED.any? { |range| range.cover?(offset) }
+            inverted == upper ? byte : byte ^ 0xff
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/c64/reu/trigger.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class REU
+      # Stands in for the page at $FF00 in the write table, passing each
+      # write on to what is mapped there and telling the REC when $FF00 is
+      # written, which starts an armed transfer.
+      class Trigger
+        ADDRESS = 0xff00
+
+        def initialize(reu)
+          @reu = reu
+          @target = nil
+        end
+
+        # Puts the trigger in front of target and returns it.
+        def wrap(target)
+          @target = target
+          self
+        end
+
+        def peek(addr)
+          @target.peek(addr)
+        end
+
+        def poke(addr, value)
+          @target.poke(addr, value)
+          @reu.ff00_written if addr == ADDRESS
+        end
+      end
+    end
+  end
+end