badline 0.11.1 → 0.12.1

data/lib/badline/cia.rb

@@ -61,14 +61,16 @@ module Badline
       @tb.latch = value
     end
 
-    def initialize(start: 0, peripheral: nil, model: :mos6526, region: Region::PAL)
+    # +tod_hz+ is the rate of the pulses on the TOD pin, the region's mains
+    # unless a machine feeds it otherwise, and 0 for a pin held still.
+    def initialize(start: 0, peripheral: nil, model: :mos6526, region: Region::PAL, tod_hz: nil)
       raise ArgumentError, "unknown CIA model #{model}" unless MODELS.include?(model)
 
       addressable_at(start, length: 2**8)
 
       @model = model
       @clock_hz = region.clock_hz
-      @mains_hz = region.mains_hz
+      @mains_hz = tod_hz || region.mains_hz
 
       @peripheral = peripheral
       @port_b4_handler = nil
@@ -139,9 +141,10 @@ module Badline
 
     # Port A as driven by the data/direction registers alone, without
     # peripheral pulldown. Cheap path for the VIC bank lookup.
-    def port_a_lines
-      driven_lines(@data_port_a, @data_dir_a)
-    end
+    def port_a_lines = driven_lines(@data_port_a, @data_dir_a)
+
+    # Port B as driven by the data/direction registers alone.
+    def port_b_lines = driven_lines(@data_port_b, @data_dir_b)
 
     def read_port_b
       lines = driven_lines(@data_port_b, @data_dir_b)

data/lib/badline/computer/attachments.rb

@@ -2,10 +2,12 @@
 
 module Badline
   class Computer
-    # What plugs into the machine besides its chips, the cartridge, the
-    # disk device 8 serves through the traps, a true 1541 and an REU, and
-    # their state for a snapshot.
+    # What plugs into the machine besides its chips, the cartridge, its
+    # true drives (TrueDrives) and an REU, and their state for a snapshot.
+    # The disk device 8 serves through the traps is KernalTraps'.
     module Attachments
+      include TrueDrives
+
       # Puts the cartridge in the expansion port and wires its clock and NMI
       # line to the machine, leaving the machine's state as it is. A
       # restored snapshot's cartridge comes back through here.
@@ -15,71 +17,13 @@ module Badline
         address_bus.attach_cartridge(cartridge)
       end
 
-      # Puts the storage in device 8. Mounting again swaps the disk at any
-      # point while the machine runs: the drive keeps its RAM, which only a
-      # drive reset clears, and its status. The traps go on the KERNAL the
-      # machine runs (#trap_layout).
-      def mount(storage)
-        return @drive.insert(storage) if @drive
-
-        @drive = KernalTrap::Drive.new(storage)
-        install_kernal_traps(trap_layout)
-      end
-
-      # Takes device 8's mounted storage out, and with it the LOAD, SAVE and
-      # serial traps, so the KERNAL's routines go out over the serial bus.
-      # Mounting again starts a new drive, with its RAM cleared.
-      def unmount
-        return unless @drive
-
-        remove_kernal_traps
-        @drive = nil
-      end
-
-      # Whether device 8 serves a disk or directory through the traps.
-      def mounted? = !@drive.nil?
-
       # The serial bus, which CIA 2's port A drives through the C64's own
       # inverters and reads back on PA6 and PA7, with or without a drive on
       # it.
       attr_reader :iec_bus
 
-      # 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
-      # 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
-        @drive1541 = drive
-        drive.connect(iec_bus)
-        @serial_trap&.device = serial_trap_device
-      end
-
-      # The true drive on the serial bus: the Drive1541, or nil.
-      def true_drive = @drive1541
-
-      # Plugs a Drive1541 in as device 8, and returns it.
-      def plug_true_drive = Drive1541.new.tap { |drive| attach_drive1541(drive) }
-
-      # Unplugs the Drive1541, leaving the serial bus with nothing on it.
-      def detach_drive1541
-        return unless @drive1541
-
-        @iec_bus.detach(@drive1541)
-        @drive1541 = nil
-        @serial_trap&.device = serial_trap_device
-      end
-
       private
 
-      # The device number the serial traps answer: device 8, unless a true
-      # drive is on the bus as device 8.
-      def serial_trap_device
-        @drive1541&.device == KernalTrap::Routine::DEVICE ? nil : KernalTrap::Routine::DEVICE
-      end
-
       # CIA 2's port A drives the serial bus, which reads CLK and DATA back
       # into it.
       def plug_serial_bus
@@ -110,46 +54,21 @@ module Badline
         end
       end
 
-      # The disk device 8 serves through the traps, with the traps' own
-      # state: open channels, the drive's status and RAM, a SAVE under way.
-      def save_trap_drive(out)
-        out.boolean(!@drive.nil?)
-        return unless @drive
-
-        @drive.save_state(out)
-        @serial_trap.save_state(out)
-        @save_trap.save_state(out)
-      end
-
-      def load_trap_drive(input)
-        return unmount unless input.boolean?
-
-        storage = Storage.reopen(input)
-        unmount
-        mount(storage)
-        @drive.load_state(input)
-        @serial_trap.load_state(input)
-        @save_trap.load_state(input)
-      end
-
-      # A true 1541 on the serial bus. The leading flag is the bus itself,
-      # which every machine now has, kept so older snapshots still load.
+      # 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?)
-        return unless @drive1541
-
-        out.int(@drive1541.device)
-        @drive1541.save_state(out)
+        if @drive1541
+          out.int(@drive1541.device)
+          @drive1541.save_state(out)
+        end
+        save_drive1581(out)
       end
 
       def load_serial_bus(input)
         input.boolean?
-        return detach_drive1541 unless input.boolean?
-
-        device = input.int
-        detach_drive1541 if @drive1541 && @drive1541.device != device
-        attach_drive1541(Drive1541.new(device:)) unless @drive1541
-        @drive1541.load_state(input)
+        load_drive1541(input)
+        load_drive1581(input)
       end
 
       # The REU, which the setup says the machine has, and whether it has

data/lib/badline/computer/common.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Badline
+  class Computer
+    # What the C128 does as the C64 does: the NMI line, a PRG put into RAM
+    # and the region's timing. Computer and C128 each include it.
+    module Common
+      # 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
+
+      def load_prg(data)
+        uint16(data[0], data[1]).tap do |load_addr|
+          ram.write(load_addr, data[2..])
+        end
+      end
+
+      private
+
+      # 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
+    end
+  end
+end

data/lib/badline/computer/kernal_traps.rb

@@ -2,18 +2,56 @@
 
 module Badline
   class Computer
-    # The LOAD, SAVE and serial traps on the KERNAL a KernalTrap::Layout
-    # describes, which serve the disk in device 8 (Attachments#mount).
+    # The disk device 8 serves through the LOAD, SAVE and serial traps, and
+    # CHROUT capture, on the KERNAL the machine runs. Computer, Vic20 and
+    # C128 each include it and answer two private methods: #trap_layout,
+    # the KernalTrap::Layout of that KERNAL, and #trap_bus, the bus the
+    # traps read and write through.
     module KernalTraps
+      # Puts the storage in device 8. Mounting again swaps the disk at any
+      # point while the machine runs: the drive keeps its RAM, which only a
+      # drive reset clears, and its status. The traps go on the KERNAL the
+      # machine runs (#trap_layout).
+      def mount(storage)
+        return @drive.insert(storage) if @drive
+
+        @drive = KernalTrap::Drive.new(storage)
+        install_kernal_traps(trap_layout)
+      end
+
+      # Takes device 8's mounted storage out, and with it the LOAD, SAVE and
+      # serial traps, so the KERNAL's routines go out over the serial bus.
+      # Mounting again starts a new drive, with its RAM cleared.
+      def unmount
+        return unless @drive
+
+        remove_kernal_traps
+        @drive = nil
+      end
+
+      # Whether device 8 serves a disk or directory through the traps.
+      def mounted? = !@drive.nil?
+
+      # The path of the disk or directory device 8 serves through the
+      # traps, or an empty one.
+      def mounted_path = @drive.nil? ? "" : @drive.path
+
+      # Records what the KERNAL prints through CHROUT (ChroutTrap).
+      def capture_output
+        @capture_output ||= ChroutTrap.new(cpu:, bus: trap_bus, layout: trap_layout).tap do |trap|
+          cpu.install_trap(ChroutTrap::ADDRESS) { trap.call }
+        end
+      end
+
       private
 
       def install_kernal_traps(layout)
         @trap_layout = layout
-        load_trap = KernalTrap::Load.new(cpu:, bus: address_bus, layout:, drive: @drive)
+        load_trap = KernalTrap::Load.new(cpu:, bus: trap_bus, layout:, drive: @drive)
         cpu.install_trap(layout.load) { load_trap.call }
-        @serial_trap = KernalTrap::Serial.new(cpu:, bus: address_bus, layout:, drive: @drive,
+        @serial_trap = KernalTrap::Serial.new(cpu:, bus: trap_bus, layout:, drive: @drive,
                                               device: serial_trap_device).install
-        save_trap = @save_trap = KernalTrap::Save.new(cpu:, bus: address_bus, layout:, drive: @drive)
+        save_trap = @save_trap = KernalTrap::Save.new(cpu:, bus: trap_bus, layout:, drive: @drive)
         cpu.install_trap(layout.save) { save_trap.call }
       end
 
@@ -24,6 +62,28 @@ module Badline
         @serial_trap = nil
         @save_trap = nil
       end
+
+      # The disk device 8 serves through the traps, with the traps' own
+      # state: open channels, the drive's status and RAM, a SAVE under way.
+      def save_trap_drive(out)
+        out.boolean(!@drive.nil?)
+        return unless @drive
+
+        @drive.save_state(out)
+        @serial_trap.save_state(out)
+        @save_trap.save_state(out)
+      end
+
+      def load_trap_drive(input)
+        return unmount unless input.boolean?
+
+        storage = Storage.reopen(input)
+        unmount
+        mount(storage)
+        @drive.load_state(input)
+        @serial_trap.load_state(input)
+        @save_trap.load_state(input)
+      end
     end
   end
 end

data/lib/badline/computer/true_drives.rb

@@ -0,0 +1,69 @@
+# 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,
+    # Vic20 and C128 each include it.
+    module TrueDrives
+      include Drive1581::Slot
+
+      # Plugs in a Drive1541, 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 = timing.clock_hz
+        @drive1541 = drive
+        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.
+      def true_drive = @drive1581 || @drive1541
+
+      # Plugs a Drive1541 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) }
+      end
+
+      # Unplugs the Drive1541, leaving the serial bus with nothing on it.
+      def detach_drive1541
+        return unless @drive1541
+
+        @iec_bus.detach(@drive1541)
+        @drive1541 = nil
+        @serial_trap&.device = serial_trap_device
+      end
+
+      private
+
+      # The device number the serial traps answer: device 8, unless a true
+      # drive is on the bus as device 8.
+      def serial_trap_device
+        device = KernalTrap::Routine::DEVICE
+        @drive1541&.device == device || drive1581_on_device8? ? nil : device
+      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
+        @drive1541.load_state(input)
+      end
+    end
+  end
+end

data/lib/badline/computer.rb

@@ -1,5 +1,7 @@
 # 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"
@@ -8,16 +10,14 @@ module Badline
   class Computer
     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
@@ -77,6 +77,7 @@ module Badline
       @serial_trap = nil
       @save_trap = nil
       @drive1541 = nil
+      @drive1581 = nil
       plug_serial_bus
       @reu = reu ? plug_reu(reu) : nil
     end
@@ -101,50 +102,22 @@ module Badline
       watch_freeze if @freezing
       clock_cpu
       @drive1541&.host_cycle!
+      @drive1581&.host_cycle!
 
       @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!
@@ -174,6 +147,7 @@ module Badline
       @dma = false
       @drive&.reset!
       @drive1541&.reset!
+      @drive1581&.reset!
       @freezing = false
       @nmi_asserted = false
       cpu.reset!
@@ -204,37 +178,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)
@@ -274,13 +223,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

data/lib/badline/core.rb

@@ -15,6 +15,7 @@ require "badline/memory"
 require "badline/color_memory"
 require "badline/rom"
 require "badline/ram_expansion"
+require "badline/cpu_port"
 require "badline/address_bus"
 require "badline/instruction"
 require "badline/instruction_set"
@@ -23,7 +24,6 @@ require "badline/keyboard"
 require "badline/joystick"
 require "badline/control_ports"
 require "badline/input"
-require "badline/cycleable"
 require "badline/datasette"
 require "badline/time_of_day"
 require "badline/cia"
@@ -38,8 +38,11 @@ require "badline/vic"
 require "badline/keyboard_buffer"
 require "badline/iec_bus"
 require "badline/drive1541"
+require "badline/drive1581"
+require "badline/drive1581/slot"
 require "badline/snapshot/state"
 require "badline/snapshot/setup"
+require "badline/machine"
 require "badline/computer"
 require "badline/vic20"
 require "badline/checkpoint"
@@ -48,4 +51,3 @@ require "badline/cartridge"
 require "badline/kernal_trap"
 require "badline/chrout_trap"
 require "badline/media"
-require "badline/machine"

data/lib/badline/cpu_port.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Badline
+  # The I/O port of the 6510 and the 8502 at $00 (direction) and $01
+  # (data). An input pin reads its pull-up, P4 reads the datasette's sense
+  # line, and a pin without a pull-up holds the charge last driven onto
+  # it. P5 drives the datasette motor through an inverter: low runs it.
+  #
+  # The 6510 has pull-ups on P0-P2 and P4 and leaves P3, P6 and P7
+  # floating. The 8502 adds a CAPS LOCK pin on P6, high while the key is
+  # up.
+  class CPUPort
+    TAPE_SENSE = 0b0001_0000
+
+    # The direction and output registers, and the charge on the floating
+    # pins.
+    attr_reader :ddr, :data, :floating
+
+    # The port as the banking logic reads it (PortStatus).
+    attr_reader :status
+
+    # Whether CAPS LOCK is down, holding its pin low.
+    attr_reader :caps_lock
+
+    # +pullups+ and +floating+ are the masks of the pins with a pull-up and
+    # of the floating ones, and +caps_lock+ the CAPS LOCK pin's, 0 where
+    # there is none.
+    def initialize(datasette, pullups:, floating:, caps_lock: 0)
+      @datasette = datasette
+      @pullups = pullups
+      @floating_mask = floating
+      @caps_lock_pin = caps_lock
+      @caps_lock = false
+      @ddr = 0x00
+      @data = 0x00
+      @floating = 0x00
+      @change_handler = nil
+      @status = PortStatus.new(%i[basic kernal io tape_out tape_switch tape_motor], value: input_value)
+    end
+
+    # Calls the block after every write to the port, for the bus to remap
+    # its banks.
+    def on_change(&handler)
+      @change_handler = handler
+    end
+
+    # What a read of $01 sees.
+    def value = @status.value
+
+    def write_ddr(value)
+      @ddr = value
+      update
+    end
+
+    def write_data(value)
+      @data = value
+      update
+    end
+
+    # The RES line clears the direction and output registers. The floating
+    # pins keep their charge.
+    def reset!
+      @ddr = 0x00
+      @data = 0x00
+      update
+    end
+
+    # Sets the registers and the charge, as a snapshot restores them, and
+    # drives the motor and calls the change handler as a write does.
+    def restore(ddr, data, floating)
+      load(ddr, data, floating)
+      update
+    end
+
+    # Sets the registers and the charge, as a snapshot loads them, without
+    # driving the motor or calling the change handler.
+    def load(ddr, data, floating)
+      @ddr = ddr
+      @data = data
+      @floating = floating
+      refresh
+    end
+
+    # Holds CAPS LOCK down, or lets it up.
+    def caps_lock=(down)
+      @caps_lock = down
+      refresh
+    end
+
+    # Reads the inputs again, after the datasette's sense line changes.
+    def refresh
+      @status.value = input_value
+    end
+
+    private
+
+    def update
+      driven = @ddr & @floating_mask
+      @floating = (@floating & ~driven) | (@data & driven)
+      refresh
+      @datasette.motor = !@status.tape_motor?
+      @change_handler&.call
+    end
+
+    def input_value
+      input = @pullups | (@floating & @floating_mask)
+      input |= @caps_lock_pin unless @caps_lock
+      input &= ~TAPE_SENSE if @datasette.sense_low?
+      (@data & @ddr) | (input & ~@ddr & 0xff)
+    end
+  end
+end