badline 0.12.1 → 0.14.0

data/lib/badline/drive/fast_serial.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drive
-    # Fast serial on a drive with a CIA, the 1571's 6526 or the 1581's
-    # 8520: through buffers a port line turns round, the CIA's CNT drives
-    # SRQ and its SP drives DATA, or it hears them. The drive pushes its
-    # pins into the bus as they move, and hears the host's as the host
-    # pushes them, pin by pin, so each byte goes through both shift
-    # registers bit by bit. The CIA takes no part in a pass of the idle
-    # loop, and any access to it, or the host moving its fast serial pins,
-    # wakes the drive.
-    #
-    # A model includes it beside Core, and calls turn_fast_serial when its
-    # direction line moves and drive_fast_serial each cycle the buffers
-    # face out. Its serial_output carries @fast_output above its port.
-    module FastSerial
-      # Whether the buffers face out, the drive's CIA driving DATA and SRQ.
-      attr_reader :fast_serial_out
-
-      # The host moved its fast serial pins: the CIA hears SRQ on CNT and
-      # DATA on SP while the buffers face in.
-      def fast_lines_moved
-        settle!
-        hear_fast_serial unless @fast_serial_out
-      end
-
-      private
-
-      def init_fast_serial
-        @fast_serial_out = false
-        @fast_output = 0
-      end
-
-      # The buffers turned round: outwards the CIA's pins drive the lines,
-      # and inwards they let go and hear them.
-      def turn_fast_serial(out)
-        @fast_serial_out = out
-        return unless @serial_bus
-
-        push_fast_output(out ? fast_pins : 0)
-        hear_fast_serial unless out
-      end
-
-      def drive_fast_serial
-        low = fast_pins
-        push_fast_output(low) if low != @fast_output
-      end
-
-      # The lines the CIA's CNT and SP pull while its serial port drives
-      # them.
-      def fast_pins
-        serial = @cia.serial
-        return 0 unless serial.output?
-
-        low = serial.cnt ? 0 : IECBus::DRIVE_FAST_SRQ
-        serial.sp_out ? low : low | IECBus::DRIVE_FAST_DATA
-      end
-
-      def push_fast_output(low)
-        @fast_output = low
-        @serial_bus&.drives_fast_moved!
-      end
-
-      def hear_fast_serial
-        low = @serial_bus.low_lines
-        serial = @cia.serial
-        serial.cnt_in = low.nobits?(IECBus::SRQ)
-        serial.sp_in = low.nobits?(IECBus::DATA)
-      end
-    end
-  end
-end

data/lib/badline/drive/idle.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drive
-    # Skipping the drive's cycles while the DOS idles, exactly.
-    #
-    # With nothing to do, the DOS goes round its idle loop from the
-    # model's @idle_loop ($EBFF in the 1541, 446 cycles a pass), until VIA
-    # 2's timer 1 interrupts it every 14,850 cycles for the job loop, or
-    # ATN interrupts it through VIA 1's CA1. A pass writes RAM and VIA 2's
-    # port B, but puts back what it found, so the drive comes round to the
-    # loop's start as it left it. Only the timers' counters and the cycle
-    # counts move.
-    #
-    # Each time the CPU comes to the loop's start, the drive records the
-    # pass that follows. At the next it checks that the pass
-    #
-    # - left the CPU, both VIAs but for their counters, the bus's last
-    #   byte, the SO pin, the mechanism (Mechanism#idle_state) and what
-    #   the ports read from it, and every byte of RAM it read or wrote as
-    #   it found them (Bus#watch!)
-    # - read nothing that changes from pass to pass: no counter, no shift
-    #   register, and not VIA 1's port B, which reads the serial bus
-    # - wrote nothing that reaches outside the drive: not VIA 1, whose port
-    #   B drives the serial bus, and not the motor on
-    # - ran while no counter could set a flag (VIA#quiet_cycles), with the
-    #   motor off, no interrupt pulled and no trap on the CPU.
-    #
-    # Such a pass runs the same way again from where it ended, for as
-    # long as ATN holds still and no counter sets a flag, so the drive
-    # sleeps: host_cycle! only counts the host cycles that go by (see
-    # Sleep). It wakes
-    # when ATN moves, when a counter is due to set a flag, or when something
-    # outside reads or changes the drive (the readers in Core call
-    # settle!). Waking counts off the whole passes it owes in bulk,
-    # moving the counters on, and runs the rest cycle by cycle.
-    #
-    # The loop reads neither CLK nor DATA, so the drive sleeps through them
-    # moving and takes the C64's lines as they stand once it wakes. Its
-    # own lines hold still while it sleeps, so the C64 reads them without
-    # waking it (serial_output).
-    #
-    # A pass starts at the loop's start, where the CPU always comes from
-    # the loop's last instruction, a JMP, so what that leaves in the CPU's
-    # working registers is the same each time round.
-    #
-    # The timer's interrupts come round too, and once they do, the drive
-    # sleeps on through them (see Orbit).
-    module Idle
-      # Whether the drive may sleep through its idle loop. On by default,
-      # but for a drive whose CPU logs each instruction.
-      attr_reader :idle_skip
-
-      def idle_skip=(on)
-        settle!
-        @idle_skip = on
-      end
-
-      private
-
-      def init_idle(debug)
-        @idle_skip = !debug
-        @recording = false
-        @pass_cycles = 0
-        @pass_instructions = 0
-        init_sleep
-        init_orbits
-      end
-
-      # The CPU is at the loop's start. At an instruction boundary, the
-      # drive sleeps if the pass it recorded can repeat, and otherwise
-      # records the next.
-      def idle_loop_reached
-        return unless @cpu.boundary?
-
-        if @recording
-          stop_recording
-          return fall_asleep if repeatable_pass? && room_for_pass?
-        end
-        start_recording
-      end
-
-      def start_recording
-        return if busy_for_pass? || @cpu.trapped?
-
-        @recording = true
-        @record_state = idle_state
-        @record_cycles = @cycles
-        @record_instructions = @cpu.instructions
-        @record_quiet = quiet_cycles
-        @bus.watch!
-      end
-
-      def stop_recording
-        @recording = false
-        @bus.unwatch!
-      end
-
-      # Whether the pass just recorded can repeat.
-      def repeatable_pass?
-        !@bus.volatile && @cycles - @record_cycles <= @record_quiet && idle_state == @record_state &&
-          ram_as_found?
-      end
-
-      # Whether the counters leave room for a whole pass.
-      def room_for_pass? = quiet_cycles >= @cycles - @record_cycles
-
-      # Sleeps through the pass just recorded, over and over.
-      def fall_asleep
-        @pass_cycles = @cycles - @record_cycles
-        @pass_instructions = @cpu.instructions - @record_instructions
-        @asleep = true
-        @host_still = false
-        @owed = 0
-        @budget = quiet_cycles
-        anchor
-      end
-
-      def ram_as_found?
-        ram = @bus.ram
-        @bus.touched.all? { |addr, value| ram.peek(addr) == value }
-      end
-    end
-  end
-end

data/lib/badline/drive/idle_cpu.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drive
-    # What Idle needs of a drive's 6502, which includes it beside
-    # CPU::Core.
-    module IdleCPU
-      # Everything the CPU holds but its cycle and instruction counts: the
-      # registers, the interrupt lines and pipeline, and what the last
-      # instruction left in its working registers. Drive::Idle compares
-      # it at two instruction boundaries.
-      def idle_state
-        [@program_counter, @stack_pointer, @a, @x, @y, @status.value,
-         @irq, @nmi, @irq_sample, @irq_pending, @nmi_sample, @nmi_pending, @skip_poll,
-         @boundary_irq, @boundary_nmi, @so_high, @interrupt, @brk, @pending_write, @stalled_at, @traps,
-         @operation, @optional_dummy, @boundary_crossed, @branch_taken,
-         @address, @pointer, @dummy_address, @value, @rmw_result]
-      end
-
-      # Counts +cycles+ cycles and +instructions+ instructions that ran
-      # without changing anything idle_state holds.
-      def fast_forward(cycles, instructions)
-        @cycles += cycles
-        @instructions += instructions
-      end
-    end
-  end
-end

data/lib/badline/drive/orbit.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drive
-    # Sleeping through the DOS's timer interrupts, exactly, once they come
-    # round.
-    #
-    # VIA 2's timer 1 interrupts the idle loop for the job loop, which
-    # finds no job, restarts the timer and returns into the pass it cut
-    # into, 14,998 cycles and more apart. The interrupts land at a
-    # different point in the pass each time, until, six of them on, the
-    # whole drive is back where it was: an orbit of 90,044 cycles.
-    #
-    # Each place the drive falls asleep (see Idle) is an anchor, and the
-    # drive keeps everything it holds at each one: RAM, the counters of
-    # the timers that are armed or that it read or wrote since, and the
-    # rest as Idle compares a pass. It keeps them only while it keeps to
-    # itself, with Bus#guard! checking that it doesn't read the serial
-    # bus, write VIA 1, turn the motor on or change the LED. ATN moving,
-    # or a reader settling the drive, forgets them.
-    #
-    # Coming to an anchor it kept before closes an orbit, which runs the
-    # same way again from here for as long as ATN holds still, so the
-    # drive sleeps on without waking for its counters. Waking counts off
-    # the whole orbits it owes in bulk, moving on only the counters it
-    # never touched, and runs the rest as Idle does.
-    module Orbit
-      # How many anchors the drive keeps while it looks for an orbit.
-      ANCHORS = 32
-
-      private
-
-      def init_orbits
-        @anchors = {}
-        @orbit_cycles = nil
-        @orbit_instructions = 0
-        @bus.guard!
-      end
-
-      # The drive falls asleep at an anchor. One it came to before closes
-      # an orbit: everything from there to here runs the same way again.
-      def anchor
-        forget_orbits if @bus.tainted || @anchors.size >= ANCHORS
-        key = anchor_state
-        if (seen = @anchors[key])
-          @orbit_cycles = @cycles - seen[0]
-          @orbit_instructions = @cpu.instructions - seen[1]
-        else
-          @anchors[key] = [@cycles, @cpu.instructions]
-        end
-      end
-
-      def forget_orbits
-        @anchors.clear
-        @orbit_cycles = nil
-        @bus.guard!
-      end
-
-      # Runs whole orbits, which bring the drive back to the anchor it
-      # sleeps at but for the counters it never touched. Returns the
-      # cycles.
-      def skip_orbits(orbits)
-        cycles = orbits * @orbit_cycles
-        touched = @bus.touched_timers
-        @cpu.fast_forward(cycles, orbits * @orbit_instructions)
-        skip_chip_orbits(cycles, touched)
-        @cycles += cycles
-        cycles
-      end
-
-      # Everything the drive holds at an anchor, but for the counters of
-      # the unarmed timers it hasn't touched since it was last tainted.
-      def anchor_state
-        touched = @bus.touched_timers
-        [*idle_state, *counter_state(touched), @bus.ram.snapshot]
-      end
-    end
-  end
-end

data/lib/badline/drive/serial_lines.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drive
-    # What VIA 1's port B reads from the serial bus. DATA IN (PB0), CLK IN
-    # (PB2) and ATN IN (PB7) come through inverters, so a released line
-    # reads 0 and a pulled one 1. The jumpers on PB5 and PB6 pull a line
-    # low when closed, and both closed make device 8.
-    #
-    # The drive sees the host's side of the bus a host cycle late. The
-    # host's CIA changes its pins at the end of the cycle that writes them,
-    # and the drive's VIA samples its own late in each of its cycles, so a
-    # drive cycle that runs alongside the write reads the lines from
-    # before it. The drive runs after the host in each host cycle (see
-    # Computer#cycle!), so the port reads the host's lines as latch_host
-    # took them at the end of the last one. Fast loaders that time their
-    # transfer from an ATN edge, as VICE's drive tests do, depend on it.
-    #
-    # A model's serial port includes it, with its own port A.
-    module SerialLines
-      DATA_IN = 0x01
-      CLK_IN = 0x04
-      ATN_IN = 0x80
-      SERIAL_INPUTS = DATA_IN | CLK_IN | ATN_IN
-      JUMPERS = 0b0110_0000
-
-      attr_reader :bus
-
-      def bus=(bus)
-        @bus = bus
-        latch_host
-      end
-
-      # Takes the host's lines as the machine last pushed them into the bus,
-      # for the drive cycles of the next host cycle.
-      def latch_host
-        @host = @bus.host_lines
-      end
-
-      # The host's lines as last latched. The jumpers and the bus are the
-      # drive's wiring.
-      def save_state(out)
-        out.int(@host)
-      end
-
-      def load_state(input)
-        @host = input.int
-      end
-
-      # Whether the host has moved ATN since the last latch_host.
-      def atn_moved? = (@bus.host_lines ^ @host).anybits?(IECBus::HOST_ATN_OUT)
-
-      def atn_low? = @bus.atn_low?(@host)
-
-      def read_b(_lines)
-        low = @bus.low_lines(@host)
-        value = @port_b
-        value |= DATA_IN if low.anybits?(IECBus::DATA)
-        value |= CLK_IN if low.anybits?(IECBus::CLK)
-        value |= ATN_IN if low.anybits?(IECBus::ATN)
-        value
-      end
-
-      private
-
-      def init_serial_lines(device, bus)
-        @port_b = (0xff & ~(SERIAL_INPUTS | JUMPERS)) | (((device - 8) & 0x03) << 5)
-        @host = 0
-        self.bus = bus
-      end
-    end
-  end
-end

data/lib/badline/drive/sleep.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drive
-    # The drive asleep, as Idle and Orbit let it: host_cycle! counts the
-    # host cycles that go by, and waking turns them into drive cycles
-    # through the phase accumulator and runs them. Whole orbits and whole
-    # passes go in bulk, and the rest cycle by cycle, which may find the
-    # idle loop and put the drive back to sleep.
-    #
-    # The drive looks at ATN only when the machine may have moved it, as
-    # it pushes its lines into the bus (IECBus#host_lines=).
-    module Sleep
-      # Whether the drive is skipping its idle loop right now.
-      def asleep? = @asleep
-
-      # Brings the drive up to the present, cycle for cycle, and drops the
-      # pass it was recording and the orbits it found, since whoever called
-      # may change it. Every reader of the drive's parts calls this.
-      def settle!
-        if @asleep
-          wake!
-          @serial_port.latch_host
-          @asleep = false
-          @orbit_cycles = nil
-        end
-        stop_recording if @recording
-        forget_orbits
-      end
-
-      private
-
-      def init_sleep
-        @asleep = false
-        @host_still = false
-        @owed = 0
-        @budget = 0
-        @slept = 0
-        @wake_at = 0
-      end
-
-      # A host cycle asleep that may wake the drive. The next ones need no
-      # look at ATN until the machine pushes its lines again.
-      def doze
-        @host_still = true
-        if @serial_port.atn_moved?
-          settle!
-        elsif @slept == @wake_at
-          wake!
-          @serial_port.latch_host
-          plan_wake if @asleep
-        end
-      end
-
-      # Asleep, host_cycle! counts host cycles, and leaves it to wake! to
-      # turn them into drive cycles through the phase accumulator. This sets
-      # the host cycle that brings the drive cycles owed up to the budget.
-      # On an orbit the drive sleeps until something outside wakes it:
-      # @slept counts from 1, so it never comes to 0.
-      def plan_wake
-        @slept = 0
-        return @wake_at = 0 if @orbit_cycles
-
-        needed = ((@budget - @owed) * @host_clock_hz) - @phase
-        @wake_at = needed.positive? ? (needed + @clock_hz - 1) / @clock_hz : 1
-      end
-
-      # Runs the cycles owed.
-      def wake!
-        phase = @phase + (@slept * @clock_hz)
-        @phase = phase % @host_clock_hz
-        owed = @owed + (phase / @host_clock_hz)
-        @owed = 0
-        @slept = 0
-        catch_up(owed)
-      end
-
-      # Runs +owed+ drive cycles: whole orbits and whole passes in bulk,
-      # passes only up to the budget, and the rest cycle by cycle, which
-      # may put the drive back to sleep.
-      def catch_up(owed)
-        while owed.positive?
-          if @asleep
-            if @orbit_cycles && owed >= @orbit_cycles
-              owed -= skip_orbits(owed / @orbit_cycles)
-              next
-            end
-            @orbit_cycles = nil
-            passes = [owed, @budget].min / @pass_cycles
-            if passes.positive?
-              owed -= skip_passes(passes)
-              next
-            end
-            @asleep = false
-          end
-          run_cycle
-          owed -= 1
-        end
-      end
-
-      # Runs whole passes, moving the counters on. Returns the cycles.
-      def skip_passes(passes)
-        cycles = passes * @pass_cycles
-        @cpu.fast_forward(cycles, passes * @pass_instructions)
-        fast_forward_chips(cycles)
-        @cycles += cycles
-        @budget -= cycles
-        cycles
-      end
-    end
-  end
-end

data/lib/badline/drive/vias.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drive
-    # The two VIAs the 1541 and the 1571 share: VIA 1 facing the serial
-    # bus, its CA1 on ATN, and VIA 2 running the GCR Mechanism. A model
-    # includes it beside Core, and it answers Core's, Idle's and Orbit's
-    # questions about the chips: what they hold, how long their counters
-    # leave them quiet, and how to run them a stretch at once. A model with
-    # more chips on its bus runs them in fast_forward_more.
-    module VIAs
-      def via1
-        settle!
-        @via1
-      end
-
-      def via2
-        settle!
-        @via2
-      end
-
-      # Puts in a Disk from the .d64, .g64, .d71 or .g71 image at +path+
-      # (Drive1541::Disk.open), write-protected with `read_only`.
-      def insert_image(path, read_only: false)
-        insert(Drive1541::Disk.open(path, read_only:))
-      end
-
-      # VIA 1's port B as it drives the serial bus. It holds still while the
-      # drive sleeps, so reading it leaves the drive asleep.
-      def serial_output = @via1.port_b_output
-
-      # The serial bus's RESET line reaches the CPU and both VIAs. RAM keeps
-      # its contents.
-      def reset!
-        settle!
-        @via1.reset!
-        @via2.reset!
-        @cpu.reset!
-      end
-
-      private
-
-      # ATN reaches VIA 1's CA1 as the serial port latched it.
-      def hear_atn
-        @via1.ca1 = @serial_port.atn_low?
-      end
-
-      # Whether the drive is doing anything a pass of the idle loop can't
-      # repeat: the motor on, or a VIA pulling IRQ.
-      def busy_for_pass? = @mechanism.motor_on? || @via1.irq? || @via2.irq?
-
-      def quiet_cycles
-        [@via1.quiet_cycles, @via2.quiet_cycles].min
-      end
-
-      def idle_state
-        mechanism = @mechanism
-        [*@cpu.idle_state, *@via1.idle_state, *@via2.idle_state, @bus.data, mechanism.so_pending,
-         *mechanism.idle_state, mechanism.read_a(0xff), mechanism.read_b(0xff)]
-      end
-
-      # The counters an orbit has to bring back (VIA#counter_state).
-      def counter_state(touched)
-        [*@via1.counter_state(touched & 0x03), *@via2.counter_state(touched >> 2)]
-      end
-
-      def fast_forward_chips(cycles)
-        @via1.fast_forward(cycles)
-        @via2.fast_forward(cycles)
-        fast_forward_more(cycles)
-      end
-
-      def skip_chip_orbits(cycles, touched)
-        @via1.skip_orbits(cycles, touched & 0x03)
-        @via2.skip_orbits(cycles, touched >> 2)
-        fast_forward_more(cycles)
-      end
-
-      # Runs the model's chips beyond the VIAs +cycles+ quiet cycles at once
-      # (see quiet_cycles). The 1541 has none.
-      def fast_forward_more(_cycles) = nil
-    end
-  end
-end