badline 0.12.0 → 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,38 +1,39 @@
 # frozen_string_literal: true
 
 module Badline
-  class Computer
-    # The true drives on the C64's serial bus: a Drive1541, and a Drive1581
-    # (Drive1581::Slot), each in a field of its own, and their state for a
-    # snapshot.
+  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 C64 on its own
-      # clock and talks to it over the serial bus. The serial traps stop
+      # 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
       # still serve a mounted image.
       def attach_drive1541(drive)
         @iec_bus.detach(@drive1541) if @drive1541
-        drive.host_clock_hz = region.clock_hz
+        drive.host_clock_hz = timing.clock_hz
         @drive1541 = drive
-        drive.connect(iec_bus)
+        drive.connect(@iec_bus)
         @serial_trap&.device = serial_trap_device
+        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
 
@@ -50,29 +51,17 @@ module Badline
         @drive1541&.device == device || drive1581_on_device8? ? nil : device
       end
 
-      # A true 1541 on the serial bus, then a 1581. The leading flag is the
-      # bus itself, which every machine now has.
-      def save_serial_bus(out)
-        out.boolean(true).boolean(!@drive1541.nil?)
-        if @drive1541
-          out.int(@drive1541.device)
-          @drive1541.save_state(out)
-        end
-        save_drive1581(out)
-      end
-
-      def load_serial_bus(input)
-        input.boolean?
-        load_drive1541(input)
-        load_drive1581(input)
-      end
+      # What the machine does as a 1541 goes on its bus. The VIC-20 waits
+      # for its DOS to boot before typing.
+      def drive1541_attached = nil
 
+      # A true 1541 on the serial bus, with its device number.
       def load_drive1541(input)
         return detach_drive1541 unless input.boolean?
 
         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,24 +1,23 @@
 # frozen_string_literal: true
 
-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
+    include Common
     include Attachments
     include KernalTraps
     include SavedState
 
     attr_reader :address_bus, :cpu, :cycles, :drive1541
 
-    # The path of the disk or directory device 8 serves through the traps
-    # (Attachments), or an empty one.
-    def mounted_path = @drive.nil? ? "" : @drive.path
-
     def family = :c64
 
     def region = address_bus.region
@@ -33,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
@@ -46,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
@@ -74,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
@@ -108,46 +112,17 @@ module Badline
       @cycles += 1
     end
 
-    # Runs `count` cycles, one #cycle! after another.
-    def run_cycles(count)
-      i = 0
-      while i < count
-        cycle!
-        i += 1
-      end
-    end
-
-    # Runs cycles until the block returns true or the cycle count passes
-    # `limit`, checking before each cycle.
-    def run_until(limit)
-      cycle! until yield || @cycles > limit
-    end
-
     # The cycle at which #on_init's handlers run, once the KERNAL has booted.
     def init_threshold
       INIT_THRESHOLD
     end
 
-    # The clock, the raster and the crop of the machine's region, a pixel
-    # to a window pixel.
-    def timing
-      region = address_bus.region
-      Timing.new(clock_hz: region.clock_hz, cycles_per_line: region.cycles_per_line,
-                 lines_per_frame: region.lines_per_frame, crop: region.crop, pixel_width: 1)
-    end
-
     # The chip whose #display a front end shows.
     def video = @vic
 
     # The chip a front end records the machine's sound from.
     def sound_source = @sid
 
-    def load_prg(data)
-      uint16(data[0], data[1]).tap do |load_addr|
-        ram.write(load_addr, data[2..])
-      end
-    end
-
     def attach_cartridge(cartridge)
       connect_cartridge(cartridge)
       power_cycle!
@@ -175,7 +150,7 @@ module Badline
       address_bus.cartridge&.reset
       @reu&.reset!
       @dma = false
-      @drive&.reset!
+      @dos&.reset!
       @drive1541&.reset!
       @drive1581&.reset!
       @freezing = false
@@ -208,37 +183,12 @@ module Badline
     # The one-shot has pulsed already, so letting go does nothing.
     def release_restore; end
 
-    def capture_output
-      @capture_output ||= ChroutTrap.new(cpu:, bus: address_bus, layout: KernalTrap::C64_LAYOUT).tap do |trap|
-        cpu.install_trap(ChroutTrap::ADDRESS) { trap.call }
-      end
-    end
-
-    def inspect
-      "#<#{self.class.name} cycles=#{@cycles} cpu=(#{@cpu.inspect})>"
-    end
-
-    def on_init(&block)
-      if booting?
-        @init_handlers << block
-      else
-        block.call
-      end
-    end
-
     private
 
-    # The KERNAL the traps stand in for (Attachments#mount).
+    # The KERNAL the traps stand in for (KernalTraps#mount).
     def trap_layout = KernalTrap::C64_LAYOUT
 
-    # The NMI line is wired-OR between CIA 2, the cartridge and the RESTORE
-    # key, and the CPU takes an interrupt on its falling edge.
-    def drive_nmi
-      nmi = @cia2.interrupted? || @cartridge_nmi || @restore_pulse
-      @restore_pulse = false
-      @cpu.nmi = true if nmi && !@nmi_asserted
-      @nmi_asserted = nmi
-    end
+    def trap_bus = address_bus
 
     def plug_reu(size_kb)
       reu = REU.new(size_kb, bus: @address_bus, vic: @vic)
@@ -278,13 +228,5 @@ module Badline
       @freezing = false
       address_bus.cartridge.freeze!
     end
-
-    def booting?
-      @cycles < init_threshold
-    end
-
-    def handle_init
-      @init_handlers.each(&:call)
-    end
   end
 end