badline 0.12.1 → 0.13.0

data/lib/badline/c64/reu.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require "badline/c64/reu/ram"
+require "badline/c64/reu/dma"
+require "badline/c64/reu/trigger"
+require "badline/c64/reu/saved_state"
+
+module Badline
+  class C64
+    # A RAM Expansion Unit: the Commodore 1700 (128K), 1764 (256K) and 1750
+    # (512K), and the bigger units built around the same 8726 RAM Expansion
+    # Controller (REC), such as the CMD 1750XL, up to 16M.
+    #
+    # The REC's eleven registers sit in I/O 2 from $DF00, repeated every 32
+    # bytes up to $DFFF, as the 1764 and 1750 manuals map them. It moves
+    # bytes between the C64 and its RAM by DMA, one bus cycle each, with the
+    # CPU held off the bus. A command with the execute bit set starts a
+    # transfer, or with bit 4 clear arms the REC to start one on the next
+    # write to $FF00, so a program can bank the ROMs out first. A transfer
+    # waits for the CPU's next read cycle with BA high, and C64 then
+    # clocks it through #dma_cycle! until it hands the bus back.
+    class REU
+      include SavedState
+
+      SIZES_KB = [128, 256, 512, 1024, 2048, 4096, 8192, 16_384].freeze
+
+      # The registers, by offset.
+      STATUS = 0x00
+      COMMAND = 0x01
+      C64_LOW = 0x02
+      C64_HIGH = 0x03
+      EXPANSION_LOW = 0x04
+      EXPANSION_HIGH = 0x05
+      EXPANSION_BANK = 0x06
+      LENGTH_LOW = 0x07
+      LENGTH_HIGH = 0x08
+      INTERRUPT_MASK = 0x09
+      ADDRESS_CONTROL = 0x0a
+
+      # Status: an interrupt is pending, the block ended, a verify found a
+      # difference (the manual's fault bit), and the unit is built from 256K
+      # chips, which only the 1700 isn't. Reading the status clears the top
+      # three.
+      INTERRUPT_PENDING = 0x80
+      END_OF_BLOCK = 0x40
+      FAULT = 0x20
+      CHIPS_256K = 0x10
+
+      # Command: execute, reload the registers after the transfer, don't wait
+      # for $FF00, and the transfer type in the bottom two bits.
+      EXECUTE = 0x80
+      AUTOLOAD = 0x20
+      NO_FF00_TRIGGER = 0x10
+      TRANSFER_TYPE = 0x03
+
+      # Interrupt mask: interrupts on at all, then on the end of a block and
+      # on a fault. The low five bits aren't there and read as 1.
+      INTERRUPTS_ON = 0x80
+      INTERRUPT_ON_END = 0x40
+      INTERRUPT_ON_FAULT = 0x20
+
+      # Address control: hold the C64 address or the expansion address where
+      # it is. The low six bits aren't there and read as 1.
+      FIX_C64 = 0x80
+      FIX_EXPANSION = 0x40
+
+      # The REC's bank register has three bits, and the other five read as
+      # 1. A unit past 512K latches all eight onto its own address lines.
+      BANK_STUCK = 0xf8
+
+      attr_reader :trigger
+
+      # bus is the bus the REC reaches C64 memory through, and vic the VIC,
+      # whose phi1 fetch is what a register read finds on the bus during a
+      # transfer.
+      def initialize(size_kb, bus:, vic:)
+        raise ArgumentError, "No #{size_kb}K REU. Pick one of #{SIZES_KB.join(', ')}." unless SIZES_KB.include?(size_kb)
+
+        # The 1700's REC counts 17 address bits, the others' 19.
+        span = size_kb == 128 ? 0x20000 : 0x80000
+        @size_kb = size_kb
+        size = size_kb * 1024
+        @address_mask = [size, span].max - 1
+        @bank_bits = size > span ? 0xff : 0x07
+        @chips = size_kb == 128 ? 0 : CHIPS_256K
+        @ram = RAM.new(size, span)
+        @dma = DMA.new(@ram, span, bus)
+        @trigger = Trigger.new(self)
+        @vic = vic
+        @on_irq_change = nil
+        @on_dma = nil
+        @irq = false
+        reset!
+      end
+
+      def on_irq_change(&block)
+        @on_irq_change = block
+      end
+
+      # Called when the REC asks for the bus.
+      def on_dma(&block)
+        @on_dma = block
+      end
+
+      def irq? = @irq
+
+      # From the moment the REC asks for the bus until it hands it back.
+      def dma? = @requested || @running
+
+      # Whether the REC ran a transfer on the last cycle clocked, which it
+      # goes on doing until the cycle it lets go of the bus.
+      def holds_bus? = @running
+
+      def reset!
+        @status = @chips
+        @command = NO_FF00_TRIGGER
+        @c64 = @c64_start = 0
+        @expansion = @expansion_start = 0
+        @bank = @bank_start = 0
+        @length = @length_start = 0xffff
+        @interrupt_mask = 0x1f
+        @address_control = 0x3f
+        @armed = @requested = @running = @ba_was_low = false
+        interrupt(false)
+      end
+
+      def peek(addr)
+        return @vic.phi1_data if @running
+
+        register = addr & 0x1f
+        value = register_value(register)
+        read_status if register == STATUS
+        value
+      end
+
+      def poke(addr, value)
+        return if @running
+
+        register = addr & 0x1f
+        case register
+        when COMMAND then write_command(value)
+        when C64_LOW, C64_HIGH then @c64 = @c64_start = with_byte(@c64_start, value, register == C64_HIGH)
+        when EXPANSION_LOW, EXPANSION_HIGH
+          @expansion = @expansion_start = with_byte(@expansion_start, value, register == EXPANSION_HIGH)
+        when EXPANSION_BANK then @bank = @bank_start = value & @bank_bits
+        when LENGTH_LOW, LENGTH_HIGH
+          @length = @length_start = with_byte(@length_start, value, register == LENGTH_HIGH)
+        when INTERRUPT_MASK then write_interrupt_mask(value)
+        when ADDRESS_CONTROL then @address_control = value | 0x3f
+        end
+      end
+
+      # A write to $FF00 starts the transfer the command register armed.
+      def ff00_written
+        return unless @armed
+
+        @armed = false
+        request_bus
+      end
+
+      # Clocks the REC for a cycle, given the VIC's BA line. A requested
+      # transfer starts on the first cycle with BA high as the REC sees it,
+      # even one the CPU writes on. Pinned by REU/rmw-trigger. A fetch
+      # requested on the cycle before BA falls writes its first byte on the
+      # first BA-low cycle as well, and again when it starts. Pinned by
+      # REU/badoublewrite.
+      def dma_cycle!(ba_low)
+        late = ba_low && @vic.reu_ba_late?
+        if @requested
+          return hold_off if ba_low && !late
+
+          start_transfer
+        end
+        @dma.cycle!(ba_low, late, ba_low && @vic.reu_ba_handed_on?)
+        end_transfer unless @dma.holds_bus?
+      end
+
+      # The REU's RAM, at an address as the REC's registers give it.
+      def ram_peek(addr) = @ram.peek(addr)
+
+      def ram_poke(addr, value) = @ram.poke(addr, value)
+
+      private
+
+      def register_value(register)
+        case register
+        when STATUS then @status
+        when COMMAND then @command
+        when C64_LOW then @c64 & 0xff
+        when C64_HIGH then @c64 >> 8
+        when EXPANSION_LOW then @expansion & 0xff
+        when EXPANSION_HIGH then @expansion >> 8
+        when EXPANSION_BANK then @bank | BANK_STUCK
+        when LENGTH_LOW then @length & 0xff
+        when LENGTH_HIGH then @length >> 8
+        when INTERRUPT_MASK then @interrupt_mask
+        when ADDRESS_CONTROL then @address_control
+        else 0xff
+        end
+      end
+
+      def read_status
+        @status &= CHIPS_256K
+        interrupt(false)
+      end
+
+      # Writing either byte of an address or the length sets the value the
+      # transfer starts from, and puts the counter back to it.
+      def with_byte(word, value, high)
+        high ? (word & 0x00ff) | (value << 8) : (word & 0xff00) | value
+      end
+
+      def write_command(value)
+        @command = value
+        return if value.nobits?(EXECUTE)
+
+        @armed = value.nobits?(NO_FF00_TRIGGER)
+        request_bus unless @armed
+      end
+
+      # An interrupt enabled over a block that already ended, or a fault
+      # already found, fires at once.
+      def write_interrupt_mask(value)
+        @interrupt_mask = value | 0x1f
+        interrupt_on(@status)
+      end
+
+      def interrupt_on(events)
+        return unless @interrupt_mask.anybits?(INTERRUPTS_ON)
+        return unless (events.anybits?(END_OF_BLOCK) && @interrupt_mask.anybits?(INTERRUPT_ON_END)) ||
+                      (events.anybits?(FAULT) && @interrupt_mask.anybits?(INTERRUPT_ON_FAULT))
+
+        @status |= INTERRUPT_PENDING
+        interrupt(true)
+      end
+
+      def interrupt(level)
+        return if @irq == level
+
+        @irq = level
+        @on_irq_change&.call(level)
+      end
+
+      def request_bus
+        @requested = true
+        @ba_was_low = @vic.ba_low?
+        @on_dma&.call
+      end
+
+      def hold_off
+        @dma.write_ahead(@command & TRANSFER_TYPE, @c64, @expansion | (@bank << 16)) unless @ba_was_low
+        @ba_was_low = true
+      end
+
+      def start_transfer
+        @requested = false
+        @running = true
+        @dma.start(@command & TRANSFER_TYPE, @c64, @expansion | (@bank << 16), @length, @address_control)
+      end
+
+      # The execute bit drops and the $FF00 trigger turns off. With autoload
+      # the addresses and the length go back to where the transfer started,
+      # and otherwise they stay where it stopped.
+      def end_transfer
+        @running = false
+        @command = (@command & ~EXECUTE & 0xff) | NO_FF00_TRIGGER
+        events = @dma.events
+        @status |= events
+        @command.anybits?(AUTOLOAD) ? reload : keep_counters
+        interrupt_on(events)
+      end
+
+      def reload
+        @c64 = @c64_start
+        @expansion = @expansion_start
+        @bank = @bank_start
+        @length = @length_start
+      end
+
+      def keep_counters
+        @c64 = @dma.c64 if @address_control.nobits?(FIX_C64)
+        @length = @dma.length & 0xffff
+        return if @address_control.anybits?(FIX_EXPANSION)
+
+        address = @dma.expansion & @address_mask
+        @expansion = address & 0xffff
+        @bank = (address >> 16) & 0xff
+      end
+    end
+  end
+end

data/lib/badline/{computer → c64}/saved_state.rb

@@ -1,15 +1,10 @@
 # frozen_string_literal: true
 
 module Badline
-  class Computer
-    # The keyword arguments Computer.new takes to build the machine a
+  class C64
+    # The keyword arguments C64.new takes to build the machine a
     # State from #snapshot was taken of.
-    def self.setup(state)
-      input = Snapshot::StateReader.new(state)
-      input.marker("COMPUTER")
-      input.check_stamp
-      Snapshot::Setup.read(input)
-    end
+    def self.setup(state) = Snapshot::C64Setup.from(state)
 
     # A new machine, built as the one a State from #snapshot was taken of,
     # at that state. `detached` builds it without the host's files
@@ -44,13 +39,13 @@ module Badline
       # The state goes into a new machine first, so one that fails leaves
       # this machine as it was.
       def restore(state)
-        check_setup(Computer.setup(state))
-        Computer.restored(state)
+        check_setup(C64.setup(state))
+        C64.restored(state)
         apply_state(state)
       end
 
       # Puts a State into the machine without trying it on a new one
-      # first, for a machine built for it (Computer.restored): a state that
+      # first, for a machine built for it (C64.restored): a state that
       # fails leaves the machine part restored. `detached` restores it
       # without the host's files (Snapshot::StateReader).
       def apply_state(state, detached: false)
@@ -68,8 +63,8 @@ module Badline
       end
 
       def save_state(out)
-        out.marker("COMPUTER").stamp
-        Snapshot::Setup.of(address_bus).write(out)
+        out.marker(Snapshot::C64Setup::MARKER).stamp
+        Snapshot::C64Setup.of(address_bus).write(out)
         out.int(@cycles).boolean(@nmi_asserted).boolean(@cartridge_nmi).boolean(@restore_pulse).boolean(@freezing)
         out.int(@freeze_writes).boolean(!@pending_keys.nil?)
         out.ints(@pending_keys) if @pending_keys
@@ -77,15 +72,15 @@ module Badline
         save_cartridge(out)
         address_bus.save_state(out)
         @cpu.save_state(out)
-        save_trap_drive(out)
+        save_trap_dos(out)
         save_serial_bus(out)
         save_reu(out)
       end
 
       def load_state(input)
-        input.marker("COMPUTER")
+        input.marker(Snapshot::C64Setup::MARKER)
         input.check_stamp
-        check_setup(Snapshot::Setup.read(input))
+        check_setup(Snapshot::C64Setup.read(input))
         @cycles = input.int
         @nmi_asserted = input.boolean?
         @cartridge_nmi = input.boolean?
@@ -99,7 +94,7 @@ module Badline
         address_bus.load_state(input)
         push_serial_lines
         @cpu.load_state(input)
-        load_trap_drive(input)
+        load_trap_dos(input)
         load_serial_bus(input)
         load_reu(input)
       end
@@ -107,7 +102,7 @@ module Badline
       private
 
       def check_setup(setup)
-        ours = Snapshot::Setup.of(address_bus)
+        ours = Snapshot::C64Setup.of(address_bus)
         return if setup == ours
 
         raise Snapshot::FormatError, "the state is of a machine with #{setup}, not #{ours}"

data/lib/badline/{computer → c64}/true_drives.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 module Badline
-  class Computer
-    # The true drives on the machine's serial bus: a Drive1541, and a
-    # Drive1581 (Drive1581::Slot), each in a field of its own. Computer,
+  class C64
+    # The true drives on the machine's serial bus: a Drives::Model1541, and a
+    # Drives::Model1581 (Drives::Model1581::Slot), each in a field of its own. C64,
     # Vic20 and C128 each include it.
     module TrueDrives
-      include Drive1581::Slot
+      include Drives::Model1581::Slot
 
-      # Plugs in a Drive1541, which then runs alongside the machine on its
+      # Plugs in a Drives::Model1541, which then runs alongside the machine on its
       # own clock and talks to it over the serial bus. The serial traps stop
       # answering the drive's device number, so the KERNAL's TALK, LISTEN and
       # byte transfers reach the drive. The LOAD and SAVE traps stay, and
@@ -22,18 +22,18 @@ module Badline
         drive1541_attached
       end
 
-      # The true drive on the serial bus: the Drive1581 ahead of the
-      # Drive1541, or nil.
+      # The true drive on the serial bus: the Drives::Model1581 ahead of the
+      # Drives::Model1541, or nil.
       def true_drive = @drive1581 || @drive1541
 
-      # Plugs a Drive1541 in as device 8, in place of a 1581 there, and
+      # Plugs a Drives::Model1541 in as device 8, in place of a 1581 there, and
       # returns it.
       def plug_true_drive
         detach_drive1581 if drive1581_on_device8?
-        Drive1541.new.tap { |drive| attach_drive1541(drive) }
+        Drives::Model1541.new.tap { |drive| attach_drive1541(drive) }
       end
 
-      # Unplugs the Drive1541, leaving the serial bus with nothing on it.
+      # Unplugs the Drives::Model1541, leaving the serial bus with nothing on it.
       def detach_drive1541
         return unless @drive1541
 
@@ -61,7 +61,7 @@ module Badline
 
         device = input.int
         detach_drive1541 if @drive1541 && @drive1541.device != device
-        attach_drive1541(Drive1541.new(device:)) unless @drive1541
+        attach_drive1541(Drives::Model1541.new(device:)) unless @drive1541
         @drive1541.load_state(input)
       end
     end

data/lib/badline/{computer.rb → c64.rb}

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require "badline/computer/common"
-require "badline/computer/true_drives"
-require "badline/computer/attachments"
-require "badline/computer/kernal_traps"
-require "badline/computer/saved_state"
+require "badline/c64/common"
+require "badline/c64/true_drives"
+require "badline/c64/attachments"
+require "badline/c64/kernal_traps"
+require "badline/c64/saved_state"
 
 module Badline
-  class Computer
+  class C64
     include IntegerHelper
     include KeyboardBuffer
     include Machine::Clocking
@@ -32,6 +32,11 @@ module Badline
 
     def ram = address_bus.ram
 
+    # Reads and writes memory as the CPU sees it, through the bus.
+    def peek(addr) = address_bus.peek(addr)
+
+    def poke(addr, value) = address_bus.poke(addr, value)
+
     def keyboard = address_bus.keyboard
 
     def joystick1 = address_bus.joystick1
@@ -45,18 +50,18 @@ module Badline
     def install_debug_register(&) = address_bus.install_debug_register(&)
 
     # The machine options (sid_model:, cia_model:, vic_model:, region: and
-    # ram_expansion:) configure the AddressBus. The region sets the clock,
+    # ram_expansion:) configure the C64::Bus. The region sets the clock,
     # the VIC's raster and sprite timing, and the mains frequency the CIAs'
     # TOD clocks count. The KERNAL tells PAL from NTSC by the raster, so
     # every region boots the same ROMs. reu plugs an REU of that many K
     # into the expansion port, where it drives the IRQ line and takes the
     # bus for its transfers. kernal:, datasette: and board: fit the bus
-    # afterwards (AddressBus::Fittings): the KERNAL ROM, the cassette port,
+    # afterwards (C64::Bus::Fittings): the KERNAL ROM, the cassette port,
     # which is empty on the SX-64, and the board and case.
     def initialize(debug: false, reu: nil, **machine)
-      @address_bus = AddressBus.new(**machine.except(*AddressBus::Fittings::NAMES))
-      @address_bus.fit(**machine.slice(*AddressBus::Fittings::NAMES))
-      @cpu = CPU.new(@address_bus, debug:)
+      @address_bus = Bus.new(**machine.except(*Bus::Fittings::NAMES))
+      @address_bus.fit(**machine.slice(*Bus::Fittings::NAMES))
+      @cpu = Chips::CPU.new(@address_bus, debug:)
       @vic = @address_bus.vic
       @vic.open_bus = -> { @address_bus.ram.peek(@cpu.program_counter) }
       @cia1 = @address_bus.cia1
@@ -73,7 +78,7 @@ module Badline
       @freeze_writes = 0
       @init_handlers = []
       @pending_keys = nil
-      @drive = nil
+      @dos = nil
       @serial_trap = nil
       @save_trap = nil
       @drive1541 = nil
@@ -145,7 +150,7 @@ module Badline
       address_bus.cartridge&.reset
       @reu&.reset!
       @dma = false
-      @drive&.reset!
+      @dos&.reset!
       @drive1541&.reset!
       @drive1581&.reset!
       @freezing = false

data/lib/badline/chips/cia/fast_forward.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class CIA
+      # Running a CIA a stretch of cycles at once, for Drives::Engine::Idle.
+      module FastForward
+        # quiet_cycles for a CIA whose counters will never set a flag.
+        QUIET = 1 << 40
+
+        # Whether fast_forward can run the CIA: timer B stopped with nothing
+        # in its pipeline, no interrupt or acknowledge on its way, CNT where it
+        # was, the TOD clock stopped, and timer A either stopped, or free
+        # running (Timer#free_running?) with its interrupt masked and the
+        # serial port an idle input. Drives::Engine::Idle sleeps the 1571's CIA through
+        # such cycles, which its DOS leaves timer A running in.
+        def quiet?
+          return false unless @tb.idle? && @icr.quiet && @tod.quiet? && cnt_steady?
+
+          @ta.idle? ? @serial.idle : timer_a_free_running?
+        end
+
+        # How many cycles the CIA can run with nothing but its counters
+        # moving: as quiet? allows, but with timer B free running too, up to
+        # the cycle before it underflows. The 1581's DOS leaves timer B
+        # interrupting every 10 ms.
+        def quiet_cycles
+          return 0 unless @icr.quiet && @tod.quiet? && cnt_steady? && timer_a_quiet?
+          return QUIET if @tb.idle?
+          return 0 unless @tb.free_running? && @control_b.value.nobits?(0x60)
+
+          @tb.counter - 1
+        end
+
+        # Runs +cycles+ cycles at once while quiet? or for quiet_cycles, as
+        # cycle! would: timer A's underflows flag in the ICR, and reach the
+        # serial port's underflow line.
+        def fast_forward(cycles)
+          @tod.fast_forward(cycles)
+          @tb.fast_forward(cycles) unless @tb.idle?
+          return if @ta.idle?
+
+          @icr.flag(:timer_a) if @ta.fast_forward(cycles).positive?
+          @serial.follow_underflow(@ta.underflowed)
+        end
+
+        private
+
+        def timer_a_quiet? = @ta.idle? ? @serial.idle : timer_a_free_running?
+
+        # Timer A free running with its interrupt masked, and the serial port
+        # an idle input it only clocks.
+        def timer_a_free_running?
+          @ta.free_running? && !@control_a.serial_mode? && @icr.mask.value.nobits?(0x01) && @serial.drained?
+        end
+
+        # Whether CNT holds the level the last cycle sampled.
+        def cnt_steady? = @serial.cnt == @cnt_high && !@cnt_rise
+      end
+    end
+  end
+end