badline 0.11.0 → 0.11.1

data/lib/badline/drive1571.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "badline/drive1571/cpu"
+require "badline/drive1571/wd1770"
+require "badline/drive1571/serial_port"
+require "badline/drive1571/serial_via"
+require "badline/drive1571/bus"
+
+module Badline
+  # The 1571 disk drive, the C128D's built-in one: the 1541's 6502, two
+  # VIAs and GCR mechanism, with a second head, a 6526 CIA for fast
+  # serial, a WD1770 for MFM disks and DOS 3.0 in 32 KB of ROM. Drive::Core
+  # clocks it against the host and sleeps through the DOS's idle loop.
+  #
+  # VIA 1's port A picks the clock, 1 or 2 MHz on PA5, and the head on
+  # PA2, and reads the track 0 sensor and BYTE READY (SerialPort). The
+  # DOS resets at 2 MHz and drops to 1 MHz as a 1541 would run, which is
+  # how it stays until a C128 asks for fast serial. The disk turns at the
+  # same speed either way (Drive1541::Mechanism#clock_hz=).
+  #
+  # The CIA sits at $4000, on the IRQ line with both VIAs. Only its serial
+  # port is wired: through buffers PA1 turns round, its CNT drives SRQ and
+  # its SP 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: the drive sleeps only
+  # while the CIA is quiet (CIA#quiet?), and any access to it, or the
+  # host moving its fast serial pins, wakes the drive.
+  class Drive1571
+    include Drive::Core
+
+    CLOCK_HZ = 1_000_000
+    FAST_CLOCK_HZ = 2_000_000
+
+    # Where the DOS 3.0 idle loop starts over, as DOS 2.6's does.
+    IDLE_LOOP = 0xebff
+
+    # VIA 1's port A outputs.
+    FAST_SERIAL_OUT = 0x02
+    SIDE = 0x04
+    FAST = 0x20
+
+    # Whether PA1 turns the fast serial buffers outwards, the drive's CIA
+    # driving DATA and SRQ.
+    attr_reader :fast_serial_out
+
+    def cia
+      settle!
+      @cia
+    end
+
+    def fdc
+      settle!
+      @fdc
+    end
+
+    def model_name = "1571"
+
+    # +rom+ covers $8000-$FFFF, and defaults to the DOS image in the ROM
+    # path. +device+ is the number the jumpers on VIA 1's PB5 and PB6 set,
+    # 8 to 11.
+    def initialize(rom: nil, host_clock_hz: CLOCK_HZ, device: 8, debug: false)
+      @device = device
+      @clock_hz = CLOCK_HZ
+      @fast_serial_out = false
+      @fast_output = 0
+      @mechanism = Drive1541::Mechanism.new(slip: 2)
+      @serial_port = SerialPort.new(@mechanism, device:)
+      @via1 = SerialVIA.new(start: 0x1800, peripheral: @serial_port, drive: self)
+      @via2 = Drive1541::DiskVIA.new(start: 0x1c00, mechanism: @mechanism)
+      @cia = CIA.new(start: 0x4000)
+      @fdc = WD1770.new
+      @bus = Bus.new(rom: rom || ROM.load("dos1571.rom", 0x8000), via1: @via1, via2: @via2, cia: @cia, fdc: @fdc)
+      @cpu = CPU.new(@bus, debug:)
+      @idle_loop = IDLE_LOOP
+      @host_clock_hz = host_clock_hz
+      @phase = 0
+      @cycles = 0
+      @serial_bus = nil
+      init_idle(debug)
+      # CA1 powers up at the level of a released ATN, without an edge.
+      @via1.ca1 = false
+      @via1.reset!
+      connect(IECBus.new)
+    end
+
+    # The serial bus's RESET line reaches the CPU, both VIAs and the CIA.
+    # RAM keeps its contents.
+    def reset!
+      settle!
+      @via1.reset!
+      @via2.reset!
+      @cia.reset!
+      @cpu.reset!
+    end
+
+    # VIA 1 drives port A to +lines+: the side, the clock rate and the fast
+    # serial direction follow it.
+    def port_a_written(lines)
+      @mechanism.side = lines.anybits?(SIDE) ? 1 : 0
+      fast_serial_out = lines.anybits?(FAST_SERIAL_OUT)
+      turn_fast_serial(fast_serial_out) if fast_serial_out != @fast_serial_out
+      clock_hz = lines.anybits?(FAST) ? FAST_CLOCK_HZ : CLOCK_HZ
+      return if clock_hz == @clock_hz
+
+      @clock_hz = clock_hz
+      @mechanism.clock_hz = clock_hz
+    end
+
+    # Whether the drive runs at 2 MHz.
+    def fast? = @clock_hz == FAST_CLOCK_HZ
+
+    # VIA 1's port B, with the fast serial pins pulling DATA and SRQ
+    # (IECBus::DRIVE_FAST_DATA and DRIVE_FAST_SRQ) above it.
+    def serial_output = @via1.port_b_output | @fast_output
+
+    # The host moved its fast serial pins: the CIA hears SRQ on CNT and
+    # DATA on SP while PA1 turns the buffers inwards.
+    def fast_lines_moved
+      settle!
+      hear_fast_serial unless @fast_serial_out
+    end
+
+    # The drive's whole state, as the 1541's (Drive1541#save_state), with
+    # the CIA and the WD1770's registers. The clock rate, the side and the
+    # fast serial direction follow from VIA 1's port A.
+    def save_state(out)
+      settle!
+      out.marker("DRIVE1571")
+      out.int(@phase).int(@cycles).boolean(@mechanism.so_pending)
+      @serial_port.save_state(out)
+      @via1.save_state(out)
+      @via2.save_state(out)
+      @cia.save_state(out)
+      @fdc.save_state(out)
+      @bus.save_state(out)
+      @cpu.save_state(out)
+      @mechanism.save_state(out)
+    end
+
+    def load_state(input)
+      settle!
+      input.marker("DRIVE1571")
+      @phase = input.int
+      @cycles = input.int
+      @mechanism.so_pending = input.boolean?
+      @serial_port.load_state(input)
+      @via1.load_state(input)
+      @via2.load_state(input)
+      @cia.load_state(input)
+      @fdc.load_state(input)
+      @bus.load_state(input)
+      @cpu.load_state(input)
+      @mechanism.load_state(input)
+      @fast_serial_out = @via1.port_a_output.anybits?(FAST_SERIAL_OUT)
+      port_a_written(@via1.port_a_output)
+      push_fast_output(@fast_serial_out ? fast_pins : 0)
+      forget_orbits
+    end
+
+    private
+
+    # One drive cycle, as the 1541's (Drive1541#step), with the CIA
+    # clocked beside the VIAs and pulling IRQ with them.
+    def step
+      so = @mechanism.take_so
+      @mechanism.cycle!
+      @via1.ca1 = @serial_port.atn_low?
+      @via1.cycle!
+      @via2.cycle!
+      @cia.cycle!
+      drive_fast_serial if @fast_serial_out
+      @cpu.irq = @via1.irq? || @via2.irq? || @cia.interrupted?
+      @cpu.so! if so
+      @cpu.cycle!
+      @cycles += 1
+    end
+
+    # The VIAs' quiet cycles while the CIA is quiet, and none otherwise.
+    def quiet_cycles
+      @cia.quiet? ? [@via1.quiet_cycles, @via2.quiet_cycles].min : 0
+    end
+
+    def fast_forward_chips(cycles)
+      @cia.fast_forward(cycles)
+    end
+
+    # PA1 turned the buffers 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

data/lib/badline/frontend/app.rb

@@ -42,7 +42,7 @@ module Badline
         @pacer.start(@started)
         @menu.open? ? paused_frame : frame while @running
         @snapshots.finish
-        @computer.drive1541&.flush
+        @computer.true_drive&.flush
         @gamepads.close
         @sound.close
         @window.close

data/lib/badline/frontend/drive_led.rb

@@ -14,7 +14,7 @@ module Badline
 
       # The LED of the machine's true drive, or nil without one.
       def self.for(computer)
-        drive = computer.drive1541
+        drive = computer.true_drive
         drive ? new(drive) : nil
       end
 

data/lib/badline/frontend/menu_media.rb

@@ -28,7 +28,7 @@ module Badline
       # The expanded path of the disk in device 8, however it went in, or
       # an empty one.
       def disk_path
-        drive = @computer.drive1541
+        drive = @computer.true_drive
         unless drive.nil?
           disk = drive.disk
           return disk.nil? ? "" : disk.path.to_s
@@ -39,7 +39,7 @@ module Badline
       end
 
       def inserted?
-        drive = @computer.drive1541
+        drive = @computer.true_drive
         drive.nil? ? @computer.mounted? : !drive.disk.nil?
       end
 
@@ -73,7 +73,7 @@ module Badline
       end
 
       def eject_disk
-        drive = @computer.drive1541
+        drive = @computer.true_drive
         drive.nil? ? @computer.unmount : drive.insert(nil)
       end
 

data/lib/badline/frontend/menu_pages.rb

@@ -112,7 +112,8 @@ module Badline
         end
         toggle("WRITABLE", :writable, [%w[OFF ON], %i[protect unprotect], media.writable? ? 1 : 0])
         skip
-        info("DEVICE", @computer.drive1541.nil? ? "FAST LOADING" : "1541, TRUE DRIVE")
+        drive = @computer.true_drive
+        info("DEVICE", drive.nil? ? "FAST LOADING" : "#{drive.model_name}, TRUE DRIVE")
       end
 
       def draw_datasette

data/lib/badline/iec_bus.rb

@@ -16,6 +16,14 @@ module Badline
   # also pulls DATA while ATN IN differs from its ATN acknowledge on PB4
   # (an XOR gate), which answers ATN in hardware before the DOS gets to it.
   # SerialPort reads the lines back into VIA 1.
+  #
+  # Fast serial adds SRQ, which the C64 leaves alone. A C128 and a 1571
+  # clock bytes over it from a CIA's CNT, with the bits on DATA from its
+  # SP, through buffers each side turns towards the bus to send. A pin low
+  # pulls its line low. Each side pushes the lines it pulls when they
+  # move: the host through host_fast_lines=, which tells the drives
+  # (fast_lines_moved), and a drive through drives_fast_moved!, which
+  # tells the host (on_fast_change).
   class IECBus
     # CIA 2 port A
     HOST_ATN_OUT = 0x08
@@ -29,16 +37,56 @@ module Badline
     DRIVE_CLK_OUT = 0x08
     DRIVE_ATNA = 0x10
 
-    # The lines pulled low, as ATN, CLK and DATA bits
+    # The lines pulled low, as ATN, CLK, DATA and SRQ bits
     ATN = 0x01
     CLK = 0x02
     DATA = 0x04
+    SRQ = 0x08
+
+    # A drive's serial_output bits above VIA 1's port B: its fast serial
+    # pins pulling DATA and SRQ.
+    DRIVE_FAST_DATA = 0x100
+    DRIVE_FAST_SRQ = 0x200
 
     attr_reader :drives, :host_lines
 
+    # The lines the host's fast serial pins pull, as DATA and SRQ bits.
+    attr_reader :host_fast_lines
+
     def initialize
       @drives = []
       @host_lines = 0
+      @host_fast_lines = 0
+      @drive_fast_lines = 0
+      @on_fast_change = nil
+    end
+
+    # The host's fast serial pins moved: +low+ is the lines they pull, as
+    # DATA and SRQ bits.
+    def host_fast_lines=(low)
+      return if low == @host_fast_lines
+
+      @host_fast_lines = low
+      @drives.each(&:fast_lines_moved)
+    end
+
+    # A drive's fast serial pins moved (serial_output's fast bits).
+    def drives_fast_moved!
+      low = 0
+      @drives.each do |drive|
+        output = drive.serial_output
+        low |= DATA if output.anybits?(DRIVE_FAST_DATA)
+        low |= SRQ if output.anybits?(DRIVE_FAST_SRQ)
+      end
+      return if low == @drive_fast_lines
+
+      @drive_fast_lines = low
+      @on_fast_change&.call
+    end
+
+    # Calls the block whenever the drives move their fast serial pins.
+    def on_fast_change(&block)
+      @on_fast_change = block
     end
 
     # The machine pushes the lines it pulls, as port A bits, whenever they
@@ -58,11 +106,13 @@ module Badline
     end
 
     # One pass over everything on the bus, for a reader that wants more
-    # than one line. +host+ is the C64's port A lines as the reader sees
-    # them, which a drive takes a cycle late (see Drive1541::SerialPort).
+    # than one line, SRQ included. +host+ is the C64's port A lines as the
+    # reader sees them, which a drive takes a cycle late (see
+    # Drive::SerialLines).
     def low_lines(host = @host_lines)
       atn = host.anybits?(HOST_ATN_OUT)
-      low = atn ? ATN : 0
+      low = @host_fast_lines | @drive_fast_lines
+      low |= ATN if atn
       low |= CLK if host.anybits?(HOST_CLK_OUT)
       low |= DATA if host.anybits?(HOST_DATA_OUT)
       i = 0

data/lib/badline/machine.rb

@@ -24,7 +24,8 @@ module Badline
   # - Media: +ram+, +load_prg+, +type_text+, +mount+, +unmount+,
   #   +mounted?+, +datasette+, +attach_cartridge+,
   #   +press_cartridge_button+, +release_cartridge_button+,
-  #   +attach_drive1541+, +drive1541+, and +address_bus+ for its
+  #   +attach_drive1541+, +drive1541+, +true_drive+ and +plug_true_drive+
+  #   for the drive Media::TrueDrive plugs in, and +address_bus+ for its
   #   +cartridge+ and +detach_cartridge+.
   # - Snapshots and tests: +snapshot+, +restore+, +save_snapshot+,
   #   +install_debug_register+ and +capture_output+.
@@ -33,14 +34,15 @@ module Badline
   # input parts, with its one joystick as both +joystick1+ and +joystick2+
   # and nil for +control_ports+, and of the rest +ram+, +load_prg+,
   # +type_text+, +mount+, +unmount+, +mounted?+, +datasette+, +attach_cartridge+,
-  # +attach_drive1541+, +drive1541+, +install_debug_register+ and
-  # +capture_output+.
+  # +attach_drive1541+, +drive1541+, +true_drive+, +plug_true_drive+,
+  # +install_debug_register+ and +capture_output+.
   #
   # The C128 answers all but the cartridge button, and besides +mode+,
   # :c64, as Machine.build builds it, or :c128, +vdc+, the VDC a front
   # end can show in place of +video+ once +vdc_shown=+ renders it,
-  # +press_caps_lock+, +release_caps_lock+, +press_display_key+ and
-  # +release_display_key+.
+  # +press_caps_lock+, +release_caps_lock+, +press_display_key+,
+  # +release_display_key+, and +attach_drive1571+ and +drive1571+ for the
+  # C128D's 1571, its true drive.
   module Machine
     # A new machine of `family`, :c64, :vic20 or :c128, the model of it
     # `model` names. A C64's model is one of Model::ALL, with its SID

data/lib/badline/media/true_drive.rb

@@ -2,51 +2,54 @@
 
 module Badline
   module Media
-    # Device 8 as a true 1541 instead of the KERNAL traps. Once a Drive1541
-    # is plugged in as device 8, disk media go into it rather than into the
-    # traps, so a LOAD runs the DOS and every byte crosses the serial bus.
-    # A .g64 holds the disk's raw GCR, which only a true drive reads, so it
-    # plugs one in when there's none yet. The 1541 reads only .d64 and .g64
-    # images, so the traps' other disk media, a .d71, .d81 or .t64 or a host
-    # directory, raise Error.
+    # Device 8 as a true drive instead of the KERNAL traps: a 1541, or on
+    # the C128 its 1571. Once a true drive is plugged in as device 8, disk
+    # media go into it rather than into the traps, so a LOAD runs the DOS
+    # and every byte crosses the serial bus. A .g64 holds the disk's raw
+    # GCR, which only a true drive reads, so it plugs one in when there's
+    # none yet. The 1541 reads only .d64 and .g64 images, and the 1571
+    # .d71 and .g71 as well, so the traps' other disk media, a .d81 or
+    # .t64 or a host directory, raise Error.
     module TrueDrive
       class Error < ArgumentError; end
 
       class << self
-        # Plugs a Drive1541 in as device 8, unless one is there already, and
-        # returns it.
+        # Plugs the machine's true drive in as device 8, unless one is there
+        # already, and returns it.
         def plug(computer)
-          drive(computer) || Drive1541.new.tap { |drive| computer.attach_drive1541(drive) }
+          drive(computer) || computer.plug_true_drive
         end
 
-        # The Drive1541 on device 8, or nil.
+        # The true drive on device 8, or nil.
         def drive(computer)
-          drive = computer.drive1541
+          drive = computer.true_drive
           drive if drive && drive.device == KernalTrap::Routine::DEVICE
         end
 
-        # Whether the path goes in a true drive: a .g64 always, and other
-        # disk media, which the traps would mount, when a true drive is
-        # device 8.
+        # Whether the path goes in a true drive: a .g64 or .g71 always, and
+        # other disk media, which the traps would mount, when a true drive
+        # is device 8.
         def takes?(computer, path)
-          return true if File.extname(path).casecmp?(".g64")
+          return true if %w[.g64 .g71].include?(File.extname(path).downcase)
 
           !drive(computer).nil? && (File.directory?(path) || MOUNT_TYPES.key?(File.extname(path).downcase))
         end
 
-        # Puts the .d64 or .g64 in the drive on device 8, plugging one in
-        # when there's none, and takes out what was mounted through the
-        # traps, so LOAD and SAVE reach the drive too. `read_only` puts it
-        # in write-protected.
+        # Puts the image in the drive on device 8, plugging one in when
+        # there's none, and takes out what was mounted through the traps,
+        # so LOAD and SAVE reach the drive too. `read_only` puts it in
+        # write-protected.
         def insert(computer, path, read_only: false)
-          unless %w[.d64 .g64].include?(File.extname(path).downcase)
-            raise Error, "#{path} is not a .d64 or .g64 image, which the 1541 reads"
+          name = drive(computer)&.model_name || (computer.family == :c128 ? "1571" : "1541")
+          types = name == "1571" ? %w[.d64 .g64 .d71 .g71] : %w[.d64 .g64]
+          unless types.include?(File.extname(path).downcase)
+            raise Error, "#{path} is not a #{types[0..-2].join(', ')} or #{types.last} image, which the #{name} reads"
           end
 
           disk = Drive1541::Disk.open(path, read_only:)
           computer.unmount
           plug(computer).insert(disk)
-          "Inserted #{path} in the 1541 as device 8"
+          "Inserted #{path} in the #{name} as device 8"
         end
       end
     end

data/lib/badline/options/help.rb

@@ -60,7 +60,8 @@ module Badline
         window also autosaves every two minutes of play, which only the
         pause menu loads. Device 8 answers through traps on the KERNAL's
         disk routines, unless --true-drive puts an emulated 1541 there,
-        which runs its own DOS and reads .d64 and .g64 images only. A .sid
+        which runs its own DOS and reads .d64 and .g64 images only, or on
+        the C128 the C128D's 1571, which reads .d71 and .g71 too. A .sid
         tune opens in the SID player, as `sid` plays it, unless an option
         of the emulator's window asks for the machine.
 

data/lib/badline/options/table.rb

@@ -35,7 +35,7 @@ module Badline
       Option.new("--sound", "Play the SID through the host's audio device (F10 mutes)",
                  section: "Window options", needs: :window),
       Option.new("--no-sound", "Don't play the SID", section: "Window options", needs: :window, build: :native),
-      Option.new("--true-drive", "Put a true 1541 on device 8 instead of the KERNAL traps",
+      Option.new("--true-drive", "Put a true 1541 on device 8 instead of the KERNAL traps, a 1571 on the C128",
                  section: "Window options", needs: :window),
       Option.new("--reu SIZE", "Plug in an REU of SIZE K: 128, 256, 512 (a 1750) or up to 16384",
                  section: "Window options", needs: :window),

data/lib/badline/roms/README

@@ -61,6 +61,15 @@ https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/new/1541/
 (1541-c000.325302-01.bin and 1541-e000.901229-05.bin) and concatenated.
 SHA-1 ab16f56989b27d89babe5f89c5a8cb3da71a82f0.
 
+dos1571.rom
+-----------
+The 1571 disk drive's DOS 3.0, 310654-05, 32 KB for $8000-$FFFF.
+Drive1571 loads it.
+
+Downloaded from
+https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/new/1571/1571-rom.310654-05.bin
+SHA-1 f1be619c106641a685f6609e4d43d6fc9eac1e70.
+
 Commodore VIC-20 ROMs
 =====================
 

data/lib/badline/storage/d64_image.rb

@@ -17,6 +17,9 @@ module Badline
 
       def storage_kind = D64
 
+      # The sides of a disk the image's tracks fill.
+      def sides = 1
+
       def sectors_in(track)
         case track
         when 1..17 then 21

data/lib/badline/storage/d71_image.rb

@@ -7,6 +7,15 @@ module Badline
 
       def storage_kind = D71
 
+      # Tracks 1-35 on the first side and 36-70 on the second.
+      def track_count = 70
+
+      def sides = 2
+
+      def sectors_in(track)
+        track > 35 ? super(track - 35) : super
+      end
+
       private
 
       def error_tables = ERROR_TABLES
@@ -22,10 +31,6 @@ module Badline
       def bam_bitmap(track) = track > 35 ? [53, 0, 3 * (track - 36)] : super
 
       def double_sided? = @bytes[sector_offset(18, 0) + 3].anybits?(0x80)
-
-      def sectors_in(track)
-        track > 35 ? super(track - 35) : super
-      end
     end
   end
 end

data/lib/badline/storage/g64_image.rb

@@ -5,7 +5,9 @@ module Badline
     # A .g64 image: a 1541 disk's flux as raw GCR, track by track, for the
     # true drive to read the way it reads a real disk, copy protection and
     # all. It has no file system of its own, so only the true drive
-    # (Drive1541::Disk.from_g64) can use it.
+    # (Drive1541::Disk.from_g64) can use it. A .g71 holds a 1571 disk the
+    # same way, with "GCR-1571" for its signature and 168 half tracks,
+    # the first side's 84 and then the second's.
     #
     # The header is the signature "GCR-1541", a version byte ($00), the
     # number of half tracks the tables cover (84, tracks 1 to 42.5) and
@@ -36,6 +38,7 @@ module Badline
       class FormatError < StandardError; end
 
       SIGNATURE = "GCR-1541"
+      SIGNATURE_1571 = "GCR-1571"
       HEADER_SIZE = 12
       HALF_TRACKS = 84
       MAX_TRACK_SIZE = 7928
@@ -124,7 +127,9 @@ module Badline
       private
 
       def parse
-        raise FormatError, "Missing G64 signature" unless @data.start_with?(SIGNATURE)
+        unless @data.start_with?(SIGNATURE) || @data.start_with?(SIGNATURE_1571)
+          raise FormatError, "Missing G64 signature"
+        end
         raise FormatError, "G64 header is cut short" if @data.bytesize < HEADER_SIZE
 
         version, @half_tracks, @max_track_size = @data.byteslice(8, 4).unpack("CCv")

data/lib/badline/time_of_day.rb

@@ -52,6 +52,15 @@ module Badline
       @latch = input.boolean? ? FIELDS.to_h { |field| [field, input.int] } : nil
     end
 
+    # Whether the clock is stopped with no alarm to raise, so its cycles
+    # move only the divider's phase.
+    def quiet? = @stopped && !@alarm_pending
+
+    # Runs +cycles+ quiet cycles at once.
+    def fast_forward(cycles)
+      @accumulator = (@accumulator + (cycles * @mains_hz)) % @cycles_per_pulse
+    end
+
     def cycle!
       @accumulator += @mains_hz
       pulse! if @accumulator >= @cycles_per_pulse

data/lib/badline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Badline
-  VERSION = "0.11.0"
+  VERSION = "0.11.1"
 end

data/lib/badline/via/fast_forward.rb

@@ -3,14 +3,14 @@
 module Badline
   class VIA
     # Running a VIA a stretch of cycles at once while nothing but its
-    # counters would change, for Drive1541::Idle.
+    # counters would change, for Drive::Idle.
     module FastForward
       # quiet_cycles for a VIA that will never set a flag of its own.
       QUIET = 1 << 40
 
       # How many cycles the VIA can run with nothing but its counters
       # changing: no flag set, no pulse on a control line and no bit
-      # shifted. See Drive1541::Idle.
+      # shifted. See Drive::Idle.
       def quiet_cycles
         return 0 if @sr_uses_t2 || @shift_register.clocking? || @ca.pulsing? || @cb.pulsing?
 
@@ -26,7 +26,7 @@ module Badline
         @t2.fast_forward(cycles)
       end
 
-      # The counters an orbit (see Drive1541::Idle) has to bring back: those
+      # The counters an orbit (see Drive::Idle) has to bring back: those
       # of the armed timers, and of the timers +touched+ names (bit 0 for
       # timer 1, bit 1 for timer 2). The others only count.
       def counter_state(touched)

data/lib/badline/vic20/attachments.rb

@@ -75,6 +75,12 @@ module Badline
         @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