badline 0.11.0 → 0.12.0

data/lib/badline/drive/core.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drive
+    # What every Commodore disk drive here shares: a 6502 running the DOS
+    # ROM, with chips on its bus facing the serial bus and the disk
+    # mechanism, on a clock of its own.
+    #
+    # The drive runs on its own crystal, so it clocks against the host's
+    # clock through a fractional accumulator: each host cycle adds the
+    # drive's clock rate worth of phase, and every whole host period in it
+    # runs a drive cycle. Against the PAL C64's 985,248 Hz a drive at
+    # 1 MHz runs one drive cycle per host cycle and a second one about
+    # every 67. The host sets its clock on attaching the drive, and until
+    # then a 1 MHz drive runs one cycle per host cycle.
+    #
+    # The Mechanism reads a Disk put in with insert.
+    #
+    # While the DOS idles, host_cycle! skips the drive's cycles and catches
+    # up on them later, exactly (see Idle). The readers of the drive's parts
+    # catch up first, so they find the drive as running every cycle would
+    # have left it. Once the DOS's timer interrupts come round, the drive
+    # sleeps through them too (see Orbit).
+    #
+    # A model includes Core and builds its parts, sets @clock_hz and
+    # @idle_loop, and runs one drive cycle in step. It hears ATN on
+    # connecting (hear_atn), drives the serial bus (serial_output), and
+    # answers Idle's and Orbit's questions about its chips, as VIAs does
+    # for the 1541 and the 1571.
+    module Core
+      include Sleep
+      include Idle
+      include Orbit
+
+      attr_reader :device, :serial_bus
+
+      def cpu
+        settle!
+        @cpu
+      end
+
+      def bus
+        settle!
+        @bus
+      end
+
+      def mechanism
+        settle!
+        @mechanism
+      end
+
+      def cycles
+        settle!
+        @cycles
+      end
+
+      def ram = bus.ram
+
+      def host_clock_hz=(clock_hz)
+        settle!
+        @host_clock_hz = clock_hz
+      end
+
+      # Plugs the drive into a serial bus, leaving the one it was on. A drive
+      # starts out on a bus of its own, with nothing else on it.
+      def connect(serial_bus)
+        settle!
+        @serial_bus&.detach(self)
+        @serial_bus = serial_bus
+        @serial_port.bus = serial_bus
+        serial_bus.attach(self)
+        hear_atn
+      end
+
+      # Puts a Disk in the drive (Disk.from_d64 makes one from an image).
+      # Nil takes the disk out.
+      def insert(disk)
+        settle!
+        @mechanism.insert(disk)
+      end
+
+      def disk = mechanism.disk
+
+      # Whether the LED is lit. Reading it leaves the drive asleep: the LED
+      # is the same at the end of every pass the drive sleeps through.
+      def led_on? = @mechanism.led_on?
+
+      # Stores what the head wrote since the motor last stopped in the
+      # disk's image, as the motor stopping does.
+      def flush
+        settle!
+        @mechanism.flush
+      end
+
+      # Runs the drive cycles that fall in one host cycle: none, one or two.
+      # The host has run this cycle already, and the drive sees what it did
+      # from the next one on (see SerialPort). Asleep, the drive owes the
+      # cycles instead, until ATN moves or its counters are due (see Idle).
+      # It looks at ATN only after the machine pushed its lines into the bus
+      # (see host_written!).
+      def host_cycle!
+        if @asleep
+          return if (@slept += 1) != @wake_at && @host_still
+
+          return doze
+        end
+
+        phase = @phase + @clock_hz
+        while phase >= @host_clock_hz
+          @asleep ? @owed += 1 : run_cycle
+          phase -= @host_clock_hz
+        end
+        @phase = phase
+        settle! if @serial_port.atn_moved?
+        @serial_port.latch_host
+        plan_wake if @asleep
+      end
+
+      # The machine pushed its lines into the bus, so ATN may have moved.
+      def host_written!
+        @host_still = false
+      end
+
+      # The host moved its fast serial pins, which a 1541 has none to hear.
+      def fast_lines_moved = nil
+
+      # Runs one drive cycle, catching up first on any the drive owes (see
+      # step).
+      def cycle!
+        settle!
+        step
+      end
+
+      def inspect
+        "#<#{self.class.name} cycles=#{cycles} cpu=(#{cpu.inspect})>"
+      end
+
+      private
+
+      # A drive cycle from host_cycle!, which may find the idle loop.
+      def run_cycle
+        step
+        idle_loop_reached if @cpu.program_counter == @idle_loop && @idle_skip
+      end
+    end
+  end
+end

data/lib/badline/drive/fast_serial.rb

@@ -0,0 +1,73 @@
+# 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/{drive1541 → drive}/idle.rb

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
 
 module Badline
-  class Drive1541
+  module Drive
     # Skipping the drive's cycles while the DOS idles, exactly.
     #
-    # With nothing to do, the DOS goes round its idle loop from $EBFF,
-    # 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 $EBFF as it left it. Only the timers'
-    # counters and the cycle counts move.
+    # 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 $EBFF, the drive records the pass that
-    # follows. At the next $EBFF it checks that the pass
+    # 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
@@ -30,7 +31,7 @@ module Badline
     # 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 Drive1541 call
+    # 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.
     #
@@ -39,16 +40,13 @@ module Badline
     # own lines hold still while it sleeps, so the C64 reads them without
     # waking it (serial_output).
     #
-    # A pass starts at $EBFF, 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.
+    # 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
-      # Where the DOS 2.6 idle loop starts over.
-      IDLE_LOOP = 0xebff
-
       # 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
@@ -69,8 +67,9 @@ module Badline
         init_orbits
       end
 
-      # The CPU is at $EBFF. At an instruction boundary, the drive sleeps if
-      # the pass it recorded can repeat, and otherwise records the next.
+      # 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?
 
@@ -82,7 +81,7 @@ module Badline
       end
 
       def start_recording
-        return if @mechanism.motor_on? || @via1.irq? || @via2.irq? || @cpu.trapped?
+        return if busy_for_pass? || @cpu.trapped?
 
         @recording = true
         @record_state = idle_state
@@ -117,20 +116,10 @@ module Badline
         anchor
       end
 
-      def quiet_cycles
-        [@via1.quiet_cycles, @via2.quiet_cycles].min
-      end
-
       def ram_as_found?
         ram = @bus.ram
         @bus.touched.all? { |addr, value| ram.peek(addr) == value }
       end
-
-      def idle_state
-        mechanism = @mechanism
-        [*@cpu.idle_state, *@via1.idle_state, *@via2.idle_state, @bus.data, @so_pending,
-         *mechanism.idle_state, mechanism.read_a(0xff), mechanism.read_b(0xff)]
-      end
     end
   end
 end

data/lib/badline/drive/idle_cpu.rb

@@ -0,0 +1,28 @@
+# 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/{drive1541 → drive}/orbit.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Badline
-  class Drive1541
+  module Drive
     # Sleeping through the DOS's timer interrupts, exactly, once they come
     # round.
     #
@@ -63,8 +63,7 @@ module Badline
         cycles = orbits * @orbit_cycles
         touched = @bus.touched_timers
         @cpu.fast_forward(cycles, orbits * @orbit_instructions)
-        @via1.skip_orbits(cycles, touched & 0x03)
-        @via2.skip_orbits(cycles, touched >> 2)
+        skip_chip_orbits(cycles, touched)
         @cycles += cycles
         cycles
       end
@@ -73,8 +72,7 @@ module Badline
       # the unarmed timers it hasn't touched since it was last tainted.
       def anchor_state
         touched = @bus.touched_timers
-        [*idle_state, *@via1.counter_state(touched & 0x03), *@via2.counter_state(touched >> 2),
-         @bus.ram.snapshot]
+        [*idle_state, *counter_state(touched), @bus.ram.snapshot]
       end
     end
   end

data/lib/badline/drive/serial_lines.rb

@@ -0,0 +1,73 @@
+# 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/{drive1541 → drive}/sleep.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Badline
-  class Drive1541
+  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
@@ -62,12 +62,12 @@ module Badline
         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
+        @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 + (@slept * @clock_hz)
         @phase = phase % @host_clock_hz
         owed = @owed + (phase / @host_clock_hz)
         @owed = 0
@@ -102,8 +102,7 @@ module Badline
       def skip_passes(passes)
         cycles = passes * @pass_cycles
         @cpu.fast_forward(cycles, passes * @pass_instructions)
-        @via1.fast_forward(cycles)
-        @via2.fast_forward(cycles)
+        fast_forward_chips(cycles)
         @cycles += cycles
         @budget -= cycles
         cycles

data/lib/badline/drive/vias.rb

@@ -0,0 +1,84 @@
+# 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