badline 0.12.1 → 0.14.0

data/lib/badline/cia.rb

@@ -1,279 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/cia/interrupt_register"
-require "badline/cia/serial"
-require "badline/cia/timer"
-require "badline/cia/state"
-require "badline/cia/fast_forward"
-
-module Badline
-  # CIA (Complex Interface Adapter) chip
-  class CIA
-    include Addressable
-    include State
-    include FastForward
-
-    # The original NMOS 6526 of the breadbin C64, and the HMOS 6526A of the
-    # C64C, which differs from it only in its interrupt control register.
-    MODELS = %i[mos6526 mos6526a].freeze
-
-    attr_reader :start, :control_a, :control_b, :serial, :model
-
-    # What's on the ports outside the chip. It pulls port lines low through
-    # read_a and read_b, and on CIA 1 drives PB4 through port_b4_high?.
-    attr_accessor :peripheral
-
-    # Timer A and timer B.
-    def timers = [@ta, @tb]
-
-    # Port A and B's data and direction registers.
-    def port_registers = [@data_port_a, @data_port_b, @data_dir_a, @data_dir_b]
-
-    def interrupt_status = @icr.status
-
-    def interrupt_control = @icr.mask
-
-    def interrupt!(delay = 1) = @icr.assert!(delay)
-
-    def time_of_day = @tod
-
-    def timer_a = @ta.counter
-
-    def timer_a=(value)
-      @ta.counter = value
-    end
-
-    def timer_a_latch = @ta.latch
-
-    def timer_a_latch=(value)
-      @ta.latch = value
-    end
-
-    def timer_b = @tb.counter
-
-    def timer_b=(value)
-      @tb.counter = value
-    end
-
-    def timer_b_latch = @tb.latch
-
-    def timer_b_latch=(value)
-      @tb.latch = value
-    end
-
-    # +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 = tod_hz || region.mains_hz
-
-      @peripheral = peripheral
-      @port_b4_handler = nil
-      @port_a_handler = nil
-      @port_b4_high = true
-      reset!
-    end
-
-    # The RES line: ports back to inputs, timers stopped with their latches
-    # full, interrupts masked and the TOD clock stopped at 1:00:00.0. The
-    # PB4 level carries over and is resampled on the next cycle.
-    def reset!
-      @data_port_a = 0x00
-      @data_port_b = 0x00
-      @data_dir_a = 0x00
-      @data_dir_b = 0x00
-      @port_b4_driven_high = true
-      @cnt_high = true
-      @cnt_rise = false
-      @tod = TimeOfDay.new(clock_hz: @clock_hz, mains_hz: @mains_hz)
-      @icr = InterruptRegister.new(@model)
-      @icr_status = @icr.status
-      @control_a = ControlRegister.new(%i[start output out_mode run_mode load
-                                          in_mode serial_mode clock_frequency])
-      @control_b = ControlRegister.new(%i[start output out_mode run_mode load
-                                          in_cnt in_timer_a alarm])
-      @ta = Timer.new(@control_a)
-      @tb = Timer.new(@control_b)
-      @serial = Serial.new(@control_a)
-      @port_a_handler&.call
-    end
-
-    # Register a change handler on the PB4 line. On CIA 1, this feeds the
-    # light pen input.
-    def on_port_b4_change(&handler)
-      @port_b4_handler = handler
-    end
-
-    # Register a handler for writes that can move port A's lines: to the
-    # data register or DDR, and the reset. On CIA 2, this tells the drives
-    # on the serial bus that the C64 may have moved a line.
-    def on_port_a_write(&handler)
-      @port_a_handler = handler
-    end
-
-    # A falling edge on the FLAG pin. On CIA 1 the datasette's tape read
-    # line drives it, on CIA 2 the serial bus SRQ.
-    def flag! = raise_interrupt(:flag)
-
-    def interrupted? = @icr_status.value >= 0x80
-
-    def cycle!
-      @icr.cycle! unless @icr.quiet
-      refresh_port_b4 if @port_b4_handler
-      level = @serial.cnt
-      level == @cnt_high ? @cnt_rise = false : cnt_edge(level)
-      underflowed = update_timers
-      @serial.cycle!(underflowed) { trigger_serial } if underflowed || !@serial.idle
-      @tod.cycle! { trigger_alarm }
-    end
-
-    def read_port_a
-      lines = driven_lines(@data_port_a, @data_dir_a)
-      return lines unless peripheral
-
-      lines & peripheral.read_a(lines, driven_lines(@data_port_b, @data_dir_b))
-    end
-
-    # 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)
-
-    # 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)
-      lines &= peripheral.read_b(driven_lines(@data_port_a, @data_dir_a), lines) if peripheral
-      apply_timer_output(lines)
-    end
-
-    def peek(addr)
-      case offset_of(addr) & 0x0f
-      when 0x00 then read_port_a
-      when 0x01 then read_port_b
-      when 0x02 then @data_dir_a
-      when 0x03 then @data_dir_b
-      when 0x04 then low_byte(@ta.counter)
-      when 0x05 then high_byte(@ta.counter)
-      when 0x06 then low_byte(@tb.counter)
-      when 0x07 then high_byte(@tb.counter)
-      when 0x08 then @tod.tenths
-      when 0x09 then @tod.seconds
-      when 0x0a then @tod.minutes
-      when 0x0b then @tod.hours
-      when 0x0c then @serial.data
-      when 0x0d then @icr.read
-      when 0x0e then control_a.value
-      when 0x0f then control_b.value
-      end
-    end
-
-    def poke(addr, value)
-      case offset_of(addr) & 0x0f
-      when 0x00 then update_port_a { @data_port_a = value }
-      when 0x01 then update_port_b { @data_port_b = value }
-      when 0x02 then update_port_a { @data_dir_a = value }
-      when 0x03 then update_port_b { @data_dir_b = value }
-      when 0x04 then @ta.write_latch_low(value)
-      when 0x05 then @ta.write_latch_high(value)
-      when 0x06 then @tb.write_latch_low(value)
-      when 0x07 then @tb.write_latch_high(value)
-      when 0x08 then @tod.write(:tenths, value, alarm: control_b.alarm?)
-      when 0x09 then @tod.write(:seconds, value, alarm: control_b.alarm?)
-      when 0x0a then @tod.write(:minutes, value, alarm: control_b.alarm?)
-      when 0x0b then @tod.write_hours(value, alarm: control_b.alarm?)
-      when 0x0c then @serial.write(value)
-      when 0x0d then @icr.write(value)
-      when 0x0e then write_control_a(value)
-      when 0x0f then @tb.write_control(value)
-      end
-    end
-
-    private
-
-    def update_port_a
-      yield
-      @port_a_handler&.call
-    end
-
-    def update_port_b
-      yield
-      @port_b4_driven_high = driven_lines(@data_port_b, @data_dir_b).anybits?(0x10)
-      refresh_port_b4 if @port_b4_handler
-    end
-
-    # PB4 is also control port 1's fire line, and a peripheral pulls it low
-    # without any register write, so the level is resampled every cycle rather
-    # than only after a poke.
-    def refresh_port_b4
-      high = @port_b4_driven_high && (peripheral.nil? || peripheral.port_b4_high?)
-      return if high == @port_b4_high
-
-      @port_b4_high = high
-      @port_b4_handler.call(high)
-    end
-
-    def driven_lines(register, direction)
-      # Output bits are driven from the data register; input bits float high.
-      # External peripherals can still pull any line low (wired-AND).
-      (register & direction) | (~direction & 0xff)
-    end
-
-    def apply_timer_output(value)
-      value = with_bit(value, 6, @ta.output?) if control_a.output?
-      value = with_bit(value, 7, @tb.output?) if control_b.output?
-      value
-    end
-
-    def with_bit(value, bit, set)
-      set ? value | (1 << bit) : value & ~(1 << bit)
-    end
-
-    def trigger_alarm = raise_interrupt(:alarm)
-    def trigger_serial = raise_interrupt(:serial)
-
-    def raise_interrupt(source) = @icr.flag(source)
-
-    # CNT is sampled once a cycle. When the serial port drives it from this
-    # cycle's timer A underflow, the new level is picked up on the next one.
-    def cnt_edge(level)
-      @cnt_high = level
-      @cnt_rise = level
-      @serial.rising_edge! { trigger_serial } if level
-    end
-
-    # Returns whether timer A underflowed, which clocks the serial port.
-    #
-    # CRB bits 6-5 pick timer B's source: ø2, CNT edges, timer A
-    # underflows, or timer A underflows gated by the CNT level. Every source
-    # drives the same count-enable line, so a cascaded underflow goes through
-    # the input pipeline exactly as a CNT edge does.
-    def update_timers
-      @ta.cycle!(@control_a.value & 0x20 == 0x20 ? @cnt_rise : true)
-      underflowed = @ta.underflowed
-      @tb.cycle!(
-        case @control_b.value & 0x60
-        when 0x00 then true
-        when 0x20 then @cnt_rise
-        when 0x40 then underflowed
-        else underflowed && @cnt_high
-        end
-      )
-      @icr.flag(:timer_a) if underflowed
-      @icr.timer_b_underflow! if @tb.underflowed
-      underflowed
-    end
-
-    def write_control_a(value)
-      was_output = control_a.serial_mode?
-      @ta.write_control(value)
-      @serial.reset! { trigger_serial } if control_a.serial_mode? != was_output
-      @tod.fifty_hz = control_a.clock_frequency?
-    end
-  end
-end

data/lib/badline/color_memory.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  # Colour RAM is four bits wide. A CPU read takes the upper nibble off the
-  # open data bus, which still holds the byte the VIC fetched in phi1.
-  class ColorMemory < Memory
-    def initialize(vic, start: 0xd800, length: 2**10)
-      super(start:, length:)
-      @vic = vic
-    end
-
-    def peek(addr)
-      (@vic.phi1_data & 0xf0) | @storage[offset_of(addr)]
-    end
-
-    def poke(addr, value)
-      super(addr, value & 0x0f)
-    end
-
-    # The four bits the cell stores, as the VIC's c-access sees them.
-    def nibble(addr)
-      @storage[offset_of(addr)]
-    end
-  end
-end

data/lib/badline/computer/attachments.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Computer
-    # 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.
-      def connect_cartridge(cartridge)
-        cartridge.clock = -> { @cycles }
-        cartridge.on_nmi_change { |level| @cartridge_nmi = level }
-        address_bus.attach_cartridge(cartridge)
-      end
-
-      # 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
-
-      private
-
-      # CIA 2's port A drives the serial bus, which reads CLK and DATA back
-      # into it.
-      def plug_serial_bus
-        @iec_bus = IECBus.new
-        @cia2.peripheral = @iec_bus
-        @cia2.on_port_a_write { push_serial_lines }
-        push_serial_lines
-      end
-
-      # Pushes the lines CIA 2's port A pulls into the serial bus.
-      def push_serial_lines
-        @iec_bus.host_lines = @cia2.port_a_lines
-      end
-
-      def save_cartridge(out)
-        cartridge = address_bus.cartridge
-        out.boolean(!cartridge.nil?)
-        cartridge&.save_setup(out)
-      end
-
-      # A cartridge comes back built afresh from the setup it was built
-      # with, before the address bus puts its state into it.
-      def load_cartridge(input)
-        if input.boolean?
-          connect_cartridge(Cartridge.from_setup(input))
-        elsif address_bus.cartridge
-          address_bus.detach_cartridge
-        end
-      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
-
-      # The REU, which the setup says the machine has, and whether it has
-      # asked for the bus. Its IRQ line reaches the CPU as it was.
-      def save_reu(out)
-        @reu&.save_state(out)
-        out.boolean(@dma)
-      end
-
-      def load_reu(input)
-        @reu&.load_state(input)
-        @reu_irq = @reu ? @reu.irq? : false
-        @dma = input.boolean?
-      end
-    end
-  end
-end

data/lib/badline/computer/saved_state.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Computer
-    # The keyword arguments Computer.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
-
-    # 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
-    # (Snapshot::StateReader).
-    def self.restored(state, detached: false) = setup(state).build.apply_state(state, detached:)
-
-    # The whole machine's state for a snapshot: the machine's own latches,
-    # the bus and its chips, the CPU, and what is attached to it
-    # (Attachments).
-    module SavedState
-      # How many more on_init handlers the machine a State was taken of had
-      # yet to run than this one has: they are the host's blocks, which a
-      # State can't hold. Nil until the machine is restored.
-      attr_reader :init_handlers_lost
-
-      # The machine's whole state, in memory. #restore takes the machine, or
-      # another built with the same chip models, region and RAM expansion,
-      # back to it. The cartridge, the disk in device 8, a true 1541 and its
-      # disk and the tape go in the state too. What the host holds stays
-      # out: the keyboard, the joysticks and the pot devices, the traps and
-      # callbacks, whether the display renders and whether the SID records.
-      def snapshot
-        out = Snapshot::StateWriter.new
-        save_state(out)
-        out.state
-      end
-
-      # Takes the machine back to a State from #snapshot. The machine keeps
-      # its chips, its traps and its callbacks, and puts in the cartridge,
-      # drives and tape the state has, taking out any it hasn't. Raises
-      # Snapshot::FormatError for a state of a machine built another way.
-      # 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)
-        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
-      # fails leaves the machine part restored. `detached` restores it
-      # without the host's files (Snapshot::StateReader).
-      def apply_state(state, detached: false)
-        input = Snapshot::StateReader.new(state, detached:)
-        load_state(input)
-        raise Snapshot::FormatError, "the state goes on past the machine" unless input.finished?
-
-        self
-      end
-
-      # Sets the machine's cycle count, for a snapshot from VICE, which
-      # counts from its own clock.
-      def resume_at(cycles)
-        @cycles = cycles
-      end
-
-      def save_state(out)
-        out.marker("COMPUTER").stamp
-        Snapshot::Setup.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
-        out.int(booting? ? @init_handlers.length : 0)
-        save_cartridge(out)
-        address_bus.save_state(out)
-        @cpu.save_state(out)
-        save_trap_drive(out)
-        save_serial_bus(out)
-        save_reu(out)
-      end
-
-      def load_state(input)
-        input.marker("COMPUTER")
-        input.check_stamp
-        check_setup(Snapshot::Setup.read(input))
-        @cycles = input.int
-        @nmi_asserted = input.boolean?
-        @cartridge_nmi = input.boolean?
-        @restore_pulse = input.boolean?
-        @freezing = input.boolean?
-        @freeze_writes = input.int
-        @pending_keys = nil
-        @pending_keys = input.ints if input.boolean?
-        @init_handlers_lost = [input.int - @init_handlers.length, 0].max
-        load_cartridge(input)
-        address_bus.load_state(input)
-        push_serial_lines
-        @cpu.load_state(input)
-        load_trap_drive(input)
-        load_serial_bus(input)
-        load_reu(input)
-      end
-
-      private
-
-      def check_setup(setup)
-        ours = Snapshot::Setup.of(address_bus)
-        return if setup == ours
-
-        raise Snapshot::FormatError, "the state is of a machine with #{setup}, not #{ours}"
-      end
-    end
-  end
-end

data/lib/badline/computer/true_drives.rb

@@ -1,69 +0,0 @@
-# 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/control_ports.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  # CIA 1's control ports and the keyboard matrix that spans them.
-  #
-  # Port A carries the matrix rows together with joystick 2, port B the matrix
-  # columns together with joystick 1. Every switch is active low, so the
-  # joysticks are wired-AND onto the lines *before* the matrix settles: a stick
-  # held in a direction selects rows and columns of its own, which is where
-  # hardware's phantom keypresses come from. Paddles and a 1351 mouse have
-  # buttons on those same lines.
-  #
-  # The ports also carry SID's POTX/POTY lines, which reach them through analog
-  # switches closed by CIA 1 PA6 (port 1) and PA7 (port 2). Close both and the
-  # pots sit in parallel, so SID charges through the lower of the two
-  # resistances; close neither and the lines float high. Reading a pot asks the
-  # CIA for the current select lines, since a program sets them and then goes
-  # straight to SID without touching the ports again.
-  #
-  # A matrix may have rows beyond port A's eight. Their select lines come from
-  # outside the CIA and are pushed into +extra_rows+, bit 0 for the ninth row
-  # upwards, active low like port A; idle, every line is high and none of
-  # those rows is selected. They settle with port A's lines as rows 8 and up,
-  # so their keys reach port B, but port A reads only its own eight.
-  class ControlPorts
-    PORT1_POTS = 0x40
-    PORT2_POTS = 0x80
-    FIRE = 0x10
-
-    attr_reader :keyboard, :joystick1, :joystick2
-    attr_accessor :device1, :device2, :port_a_source, :extra_rows
-
-    def initialize(keyboard:, joystick1:, joystick2:)
-      @keyboard = keyboard
-      @joystick1 = joystick1
-      @joystick2 = joystick2
-      @device1 = nil
-      @device2 = nil
-      @port_a_source = nil
-      @extra_rows = 0xff
-    end
-
-    def read_a(port_a, port_b) = scan(port_a, port_b).first & 0xff
-
-    def read_b(port_a, port_b) = scan(port_a, port_b).last
-
-    # Control port 1 pin 6 is both the port B fire line and the VIC's light
-    # pen input, so joystick 1's button and a 1351's left button latch
-    # $D013/$D014. The CIA samples this every cycle, so it skips the matrix and
-    # asks only what the port's own devices drive.
-    def port_b4_high? = port_bits(@joystick1, @device1).anybits?(FIRE)
-
-    def pot_x = selected_devices.map(&:pot_x).min || 0xff
-
-    def pot_y = selected_devices.map(&:pot_y).min || 0xff
-
-    private
-
-    def selected_devices
-      lines = @port_a_source&.port_a_lines || 0x00
-      devices = []
-      devices << @device1 if @device1 && lines.anybits?(PORT1_POTS)
-      devices << @device2 if @device2 && lines.anybits?(PORT2_POTS)
-      devices
-    end
-
-    def scan(port_a, port_b)
-      keyboard.scan((port_a & port_bits(@joystick2, @device2)) | (@extra_rows << 8),
-                    port_b & port_bits(@joystick1, @device1))
-    end
-
-    def port_bits(joystick, device)
-      device ? joystick.port_bits & device.port_bits : joystick.port_bits
-    end
-  end
-end