badline 0.11.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f8a451e4b936c57d5cf39cc7253481e5c8deff31898cb015641ed54246a68da
-  data.tar.gz: 8d1e5c8aab0d9352e31a5f7b870896aaec254dbcd55c823fe24496d820b2befc
+  metadata.gz: c2e262f4dbf07ef2d84f3a5eb673302102ecc9d4a5aa3ac87a908c6f0323c041
+  data.tar.gz: 026b7b26ce4cad94cf386a4b944c4ce34d34635e8dd8a568a352090320deabd9
 SHA512:
-  metadata.gz: d97d1b2876eafb8a51cd290c651904c798be975e0f3f7ea9ba4960a3dcaeebb6a76cc9cdad8bb5bf3ac5c732af3ec0eeddb779916b9e793292350d0749ed730f
-  data.tar.gz: 2b7f0307a605b0270490ae3155c1671e1197473a0c22edf836bce953c08ff8884d1b09ca92fd7b3bc8c4038de63b66d5b92e3e82297ecfaddd5cde592ef74493
+  metadata.gz: d99d4042bdb920cfbaa9501a2fff2a6cc155dda76518b28a58e863d95bd18ef3d891f7dff5d935cc726ae380c9659bc09f5f11f7cefda657a4926bfc06974e76
+  data.tar.gz: 670579ee105286f5b5c04aaa63d5ae6a9fee9161f6735ccd9f7764152c43e421f6024a1ba7cfead0da92a7b87cab6f03b1b53a2d2e44693a62807b4f52ab81a3

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.11.1](https://github.com/elektronaut/badline/compare/v0.11.0...v0.11.1) (2026-10-09)
+
+
+### Features
+
+* emulate the C128D's 1571 drive in 1541 and 1571 mode ([2c32d99](https://github.com/elektronaut/badline/commit/2c32d993a0449b4b537d5f82e9711b0e14604f95))
+* fast serial between the C128 and its 1571 ([34fe02f](https://github.com/elektronaut/badline/commit/34fe02f2098664c94233da9e40828b40e41b6b1a))
+
 ## [0.11.0](https://github.com/elektronaut/badline/compare/v0.10.1...v0.11.0) (2026-10-09)
 
 

data/CLAUDE.md

@@ -49,6 +49,7 @@ requires only the namespace file.
 | --- | --- | --- |
 | rspec (`spec/`) | `bundle exec rspec` | Unit behaviour, all of `lib/` |
 | SingleStepTests 65x02 | `rake test` (100 sampled cases per opcode) | CPU, per-cycle bus traces |
+| SingleStepTests z80 | `rake test` (the first 100 cases per opcode, `Z80_SAMPLE=all` for all 1,604,000) | `Z80`: registers, flags, ports and the bus pins on every T-state |
 | Wolfgang Lorenz suite | `bin/lorenz` | CPU, CIA, interrupts |
 | VICE testbench | `bin/testbench <subtree>` | `VICII/`, `CIA/`, `interrupts/`, `CPU/`, cartridges with `--carts`, the true 1541 drive with `--drive`, the VIC-20 with `--vic20`, and the C128 in C64 mode with `--c128c64` |
 | VICE SID testprogs | `bin/sidtests` | SID |
@@ -103,7 +104,7 @@ worktree and owns a different set of files.
 - The external suites under `vendor/` are gitignored, so a new worktree has
   only `vendor/.gitkeep`. From the worktree root, symlink the main
   checkout's suites into it:
-  `for d in 65x02 VICE-testprogs; do ln -sfn ../../../../vendor/$d vendor/$d; done`.
+  `for d in 65x02 z80-sample VICE-testprogs; do ln -sfn ../../../../vendor/$d vendor/$d; done`.
   The main checkout also has `vendor/OneLoad64-Games-Collection-v5`, which
   `rake vendor:checkout` doesn't fetch. Link it the same way only for
   `.sid` or media work. Don't re-run `rake vendor:checkout` there, and
@@ -129,12 +130,28 @@ worktree and owns a different set of files.
 
 ## Testing and baselines
 
-- `rake vendor:checkout` fetches SingleStepTests and VICE-testprogs into
-  `vendor/`
+- `rake vendor:checkout` fetches SingleStepTests 65x02, the Z80 sample
+  and VICE-testprogs into `vendor/`
 - `bundle exec rspec`: line coverage is about 97%. `spec/spec_helper.rb`
   fails a whole-suite run (every spec file, no filters) below 90%, while
   single-file and filtered runs skip the floor. `:slow` specs are excluded
   by default: run them with `bundle exec rspec --tag slow`
+- CI splits the spec files into shards, plain and `:slow`, by the run times
+  in `test/spec_times.json` (`bin/spec_shard`), and holds the plain shards'
+  merged coverage to the same 90%. After adding or moving expensive specs,
+  re-record the times with `bin/spec_shard --record` (its header says how)
+- Keep each plain example to a few hundred ms. A million cycles of a C64 or
+  a C128 cost 3 to 5 s of CPU, and about three times that under coverage,
+  so an example that boots a machine or runs more than about a million
+  cycles goes under `:slow`
+- Don't boot per example. Restore a machine from a State taken once
+  (`spec/support/taken_once.rb`), and share one machine between examples
+  that only read it. Assert on the cheapest oracle that proves the point: a
+  register or a RAM byte over a booted screen, a bare chip over a whole
+  machine, and the fewest cycles that reach the state
+- Before opening a pull request, run `bundle exec rspec --profile 10` (with
+  `--tag slow` for `:slow` ones) on the spec files you added or changed,
+  and hold them to that budget
 - `rake test`: SingleStepTests, plus the Minitest tests for the regression
   runners in `test/`. Run it for any CPU change
 

data/CONTRIBUTING.md

@@ -68,12 +68,17 @@ boot the whole machine and are skipped by default. Run them with
 `bundle exec rspec --tag slow`.
 
 The CPU is verified separately against the
-[65x02 single step tests](https://github.com/SingleStepTests/65x02).
-`rake test` checks the fixtures out into `vendor/65x02` first, which
-takes a moment the first time:
+[65x02 single step tests](https://github.com/SingleStepTests/65x02), and
+the Z80 against the [Z80 ones](https://github.com/SingleStepTests/z80).
+`rake test` checks the 65x02 fixtures out into `vendor/65x02` first,
+which takes a moment the first time. For the Z80 it fetches only the
+first 100 cases of each opcode's file into `vendor/z80-sample`.
+`Z80_SAMPLE=all` checks the whole Z80 suite out into `vendor/z80`
+(about 1.5 GB) and runs every case:
 
 ```sh
 bundle exec rake test
+Z80_SAMPLE=all bundle exec rake test
 ```
 
 Check style before pushing:

data/README.md

@@ -184,7 +184,8 @@ starts, and a `.sid` tune start C64 mode the same way, and so does a C64
 cartridge, through the KERNAL. `GO64` gets there from BASIC 7.0. A
 program that loads at `$1C01`, where BASIC 7.0 starts, runs, and other
 programs load at their own address. The disk in device 8 is served
-through the KERNAL traps in either mode. The C128's Z80 isn't emulated:
+through the KERNAL traps in either mode, or with `--true-drive` by the
+C128D's 1571. The C128's Z80 isn't emulated:
 the 8502 starts the machine. `--model` picks the board: `c128` (the default, the flat C128
 and the plastic C128D, PAL, with the 6581 SID and a VDC with 16K of
 RAM), `c128dcr` (the metal C128DCR, with the 8580, 6526As and a VDC with
@@ -348,8 +349,11 @@ program or `.sid` dropped on it opens the menu to ask first.
 - **C128**: C128 mode with BASIC 7.0 and C64 mode, on the 8502 with its
   port, FAST mode, the VIC-IIe with its extra keyboard lines, the 8722
   MMU, the 8563 or 8568 VDC with its 80 column display, and 128K of RAM
-  (`badline c128`). The Z80 and the 1571 aren't emulated yet.
+  (`badline c128`). The Z80 isn't emulated yet.
 - **1541**: an emulated drive running its own DOS (`--true-drive`).
+- **1571**: the C128D's drive running DOS 3.0, in 1541 mode and in 1571
+  mode at 2 MHz with both sides of a `.d71` or `.g71`, and fast serial
+  (burst) to a C128 in C128 mode (`badline c128 --true-drive`).
 - **Cartridges**: standard 8K, 16K and Ultimax, Simons' BASIC, Ocean,
   Fun Play / Power Play, Super Games, Epyx FastLoad, Westermann
   Learning, Rex Utility, C64 Game System / System 3, Dinamic, Zaxxon /

data/lib/badline/c128/drives.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    # The true drives on the C128's serial bus: a Drive1541, or the
+    # C128D's built-in 1571 (Drive1571), each in a field of its own, so
+    # neither makes the other's per-cycle call a union.
+    module Drives
+      attr_reader :drive1571
+
+      # Plugs in a Drive1571, which then runs alongside the C128 on its own
+      # clock and talks to it over the serial bus, as attach_drive1541 does
+      # for a 1541.
+      def attach_drive1571(drive)
+        @iec_bus.detach(@drive1571) if @drive1571
+        drive.host_clock_hz = region.clock_hz
+        @drive1571 = drive
+        drive.connect(iec_bus)
+        @serial_trap&.device = serial_trap_device
+      end
+
+      # Unplugs the Drive1571.
+      def detach_drive1571
+        return unless @drive1571
+
+        @iec_bus.detach(@drive1571)
+        @drive1571 = nil
+        @serial_trap&.device = serial_trap_device
+      end
+
+      # The true drive on the bus, the 1571 ahead of a 1541.
+      def true_drive = @drive1571 || @drive1541
+
+      # Plugs in the C128D's 1571 as device 8, and returns it.
+      def plug_true_drive = Drive1571.new.tap { |drive| attach_drive1571(drive) }
+
+      private
+
+      # The serial bus, with no disk in device 8's traps and no true drive.
+      def init_drives
+        @drive = nil
+        @serial_trap = nil
+        @save_trap = nil
+        @drive1541 = nil
+        @drive1571 = nil
+        plug_serial_bus
+        plug_fast_serial
+      end
+
+      # Device 8, unless a true drive is on the bus as device 8.
+      def serial_trap_device
+        device = KernalTrap::Routine::DEVICE
+        @drive1571&.device == device || @drive1541&.device == device ? nil : device
+      end
+
+      # A true 1541 (Computer::Attachments#save_serial_bus), then a 1571.
+      def save_serial_bus(out)
+        out.boolean(true).boolean(!@drive1541.nil?)
+        if @drive1541
+          out.int(@drive1541.device)
+          @drive1541.save_state(out)
+        end
+        out.boolean(!@drive1571.nil?)
+        return unless @drive1571
+
+        out.int(@drive1571.device)
+        @drive1571.save_state(out)
+      end
+
+      def load_serial_bus(input)
+        input.boolean?
+        load_drive1541(input)
+        load_drive1571(input)
+      end
+
+      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
+
+      def load_drive1571(input)
+        return detach_drive1571 unless input.boolean?
+
+        device = input.int
+        detach_drive1571 if @drive1571 && @drive1571.device != device
+        attach_drive1571(Drive1571.new(device:)) unless @drive1571
+        @drive1571.load_state(input)
+      end
+    end
+  end
+end

data/lib/badline/c128/fast_serial.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    # Fast serial: CIA 1's CNT and SP on the serial bus's SRQ and DATA,
+    # through buffers MCR's FSDIR turns round. Outwards, the machine pushes
+    # the lines the pins pull into the bus as they move. Inwards, CIA 1
+    # hears the lines whenever a drive moves its own fast serial pins
+    # (IECBus#on_fast_change).
+    module FastSerial
+      private
+
+      def plug_fast_serial
+        @fast_serial_out = false
+        @bus.mmu.on_fast_serial_change { turn_fast_serial }
+        @iec_bus.on_fast_change { hear_fast_serial unless @fast_serial_out }
+      end
+
+      # The machine's side of the serial bus each cycle: CIA 1's pins
+      # pushed while FSDIR has them out, then the drives.
+      def clock_serial_bus
+        drive_fast_serial if @fast_serial_out
+        @drive1541&.host_cycle!
+        @drive1571&.host_cycle!
+      end
+
+      def turn_fast_serial
+        push_fast_serial
+        hear_fast_serial unless @fast_serial_out
+      end
+
+      # Pushes the lines CIA 1's pins pull while FSDIR has them out. A
+      # restored machine pushes them again, its CIA 1 hearing the lines as
+      # it last did.
+      def push_fast_serial
+        @fast_serial_out = @bus.mmu.fast_serial_out?
+        @iec_bus.host_fast_lines = @fast_serial_out ? fast_pins : 0
+      end
+
+      def drive_fast_serial
+        @iec_bus.host_fast_lines = fast_pins
+      end
+
+      # The lines CIA 1's CNT and SP pull while its serial port drives
+      # them.
+      def fast_pins
+        serial = @cia1.serial
+        return 0 unless serial.output?
+
+        low = serial.cnt ? 0 : IECBus::SRQ
+        serial.sp_out ? low : low | IECBus::DATA
+      end
+
+      def hear_fast_serial
+        low = @iec_bus.low_lines
+        serial = @cia1.serial
+        serial.cnt_in = low.nobits?(IECBus::SRQ)
+        serial.sp_in = low.nobits?(IECBus::DATA)
+      end
+    end
+  end
+end

data/lib/badline/c128/mmu.rb

@@ -36,6 +36,7 @@ module Badline
       VR = 11
 
       MCR_8502 = 0x01
+      MCR_FSDIR = 0x08
       MCR_C64_MODE = 0x40
       VERSION = 0x20
 
@@ -68,6 +69,7 @@ module Badline
         @game = 1
         @exrom = 1
         @on_change = nil
+        @on_fast_serial_change = nil
         reset!
       end
 
@@ -76,7 +78,13 @@ module Badline
         @on_change = block
       end
 
+      # Calls the block whenever FSDIR turns the fast serial buffers round.
+      def on_fast_serial_change(&block)
+        @on_fast_serial_change = block
+      end
+
       def reset!
+        fast_serial_out = fast_serial_out?
         @registers.fill(0)
         @registers[MCR] = @reset_mode == :c64 ? MCR_C64_MODE | MCR_8502 : MCR_8502
         @registers[P1L] = 0x01
@@ -84,10 +92,15 @@ module Badline
         @p0h_latch = 0
         @p1h_latch = 0
         @on_change&.call
+        @on_fast_serial_change&.call if fast_serial_out
       end
 
       def c64_mode? = @registers[MCR].anybits?(MCR_C64_MODE)
 
+      # Whether MCR bit 3, FSDIR, turns the fast serial buffers outwards, so
+      # CIA 1's CNT and SP drive SRQ and DATA.
+      def fast_serial_out? = @registers[MCR].anybits?(MCR_FSDIR)
+
       # :c64 or :c128, the mode MCR bit 6 selects.
       def mode = c64_mode? ? :c64 : :c128
 
@@ -174,8 +187,10 @@ module Badline
       end
 
       def write(offset, value)
+        fast_serial_out = fast_serial_out?
         @registers[offset] = value
         @on_change&.call
+        @on_fast_serial_change&.call if fast_serial_out? != fast_serial_out
       end
     end
   end

data/lib/badline/c128/saved_state.rb

@@ -103,6 +103,7 @@ module Badline
         @cpu.load_state(input)
         load_trap_drive(input)
         load_serial_bus(input)
+        push_fast_serial
       end
 
       private

data/lib/badline/c128.rb

@@ -12,6 +12,9 @@ require "badline/c128/cpu"
 require "badline/c128/saved_state"
 require "badline/c128/keys"
 require "badline/c128/modes"
+require "badline/c128/drives"
+require "badline/c128/fast_serial"
+require "badline/drive1571"
 
 module Badline
   # The Commodore 128: the 8502 on the VIC-IIe's clock, two CIAs, the SID,
@@ -40,6 +43,8 @@ module Badline
     include Computer::KernalTraps
     include Keys
     include Modes
+    include Drives
+    include FastSerial
 
     # The C64's 8x8 matrix and the three rows K0-K2 select, in port B
     # column order.
@@ -125,12 +130,8 @@ module Badline
       @restore_pulse = false
       @init_handlers = []
       @pending_keys = nil
-      @drive = nil
-      @serial_trap = nil
-      @save_trap = nil
-      @drive1541 = nil
       @capture_output = nil
-      plug_serial_bus
+      init_drives
       enter_c64_mode if @c64_built
       @bus.on_mode_change { mode_changed }
     end
@@ -158,7 +159,7 @@ module Badline
 
       drive_nmi
       clock_bits.odd? ? clock_fast : clock_cpu
-      @drive1541&.host_cycle!
+      clock_serial_bus
 
       @cycles += 1
     end
@@ -230,7 +231,7 @@ module Badline
     end
 
     # The RES line reaches the CPU and its port, the MMU, both CIAs, the
-    # SID, the cartridge port and, through the serial bus, the drive.
+    # SID, the cartridge port and, through the serial bus, the drives.
     def reset!
       @bus.reset!
       @cia1.reset!
@@ -239,6 +240,7 @@ module Badline
       @bus.cartridge&.reset
       @drive&.reset!
       @drive1541&.reset!
+      @drive1571&.reset!
       @nmi_asserted = false
       @cpu.reset!
     end

data/lib/badline/cia/fast_forward.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Badline
+  class CIA
+    # Running a CIA a stretch of cycles at once, for Drive::Idle.
+    module FastForward
+      # Whether fast_forward can run the CIA: timer B stopped with nothing
+      # in its pipeline, no interrupt or acknowledge on its way, CNT where it
+      # was, the TOD clock stopped, and timer A either stopped, or free
+      # running (Timer#free_running?) with its interrupt masked and the
+      # serial port an idle input. Drive::Idle sleeps the 1571's CIA through
+      # such cycles, which its DOS leaves timer A running in.
+      def quiet?
+        return false unless @tb.idle? && @icr.quiet && @tod.quiet? && cnt_steady?
+
+        @ta.idle? ? @serial.idle : timer_a_free_running?
+      end
+
+      # Runs +cycles+ cycles at once while quiet?, as cycle! would: timer A's
+      # underflows flag in the ICR, and reach the serial port's underflow
+      # line.
+      def fast_forward(cycles)
+        @tod.fast_forward(cycles)
+        return if @ta.idle?
+
+        @icr.flag(:timer_a) if @ta.fast_forward(cycles).positive?
+        @serial.follow_underflow(@ta.underflowed)
+      end
+
+      private
+
+      # Timer A free running with its interrupt masked, and the serial port
+      # an idle input it only clocks.
+      def timer_a_free_running?
+        @ta.free_running? && !@control_a.serial_mode? && @icr.mask.value.nobits?(0x01) && @serial.drained?
+      end
+
+      # Whether CNT holds the level the last cycle sampled.
+      def cnt_steady? = @serial.cnt == @cnt_high && !@cnt_rise
+    end
+  end
+end

data/lib/badline/cia/serial.rb

@@ -79,6 +79,18 @@ module Badline
         @control.serial_mode?
       end
 
+      # Whether nothing is counting down or in the delay lines, so only
+      # timer A's underflows reach the register.
+      def drained? = idle?
+
+      # Takes timer A's underflow line as cycle! would have left it, with
+      # +underflowed+ its level on the last cycle, for a CIA run without
+      # the register in use (CIA#fast_forward).
+      def follow_underflow(underflowed)
+        @underflow_high = underflowed
+        @idle = !underflowed
+      end
+
       def cnt_in=(level)
         @cnt_in = level
         @cnt = level unless output?

data/lib/badline/cia/timer.rb

@@ -24,6 +24,32 @@ module Badline
         control.out_mode? ? @toggle : @underflowed
       end
 
+      # Whether the timer is stopped with nothing in its pipeline, so a
+      # cycle changes nothing.
+      def idle? = @empty && !started?
+
+      # Whether the timer counts ø2 in continuous mode with nothing pending
+      # but the reload after an underflow, so fast_forward can run it. A
+      # latch below 2 is left out.
+      def free_running?
+        started? && !@control.run_mode? && @control.value.nobits?(0x20) && @latch >= 2 && @pipe == 0b11 &&
+          (@load_delay | @oneshot_linger).zero? && (@settled || @reload)
+      end
+
+      # Runs a free-running timer +cycles+ cycles at once, as cycle! would:
+      # an underflow every latch + 1 cycles, each one followed by the
+      # reload. Returns the underflows.
+      def fast_forward(cycles)
+        return 0 if cycles.zero?
+        return after_underflow(cycles, 0) unless @settled
+
+        if cycles < @counter
+          @counter -= cycles
+          return 0
+        end
+        after_underflow(cycles - @counter, 1)
+      end
+
       def cycle!(feed)
         feed &&= @control.value & 0x01 != 0
         if @settled
@@ -98,6 +124,19 @@ module Badline
         @control.value & 0x01 != 0
       end
 
+      # Where fast_forward lands +cycles+ after an underflow, with
+      # +underflows+ underflows counted so far.
+      def after_underflow(cycles, underflows)
+        periods, rest = cycles.divmod(@latch + 1)
+        underflows += periods
+        @toggle = !@toggle if underflows.odd?
+        @underflowed = rest.zero?
+        @reload = rest.zero?
+        @counter = @latch - (rest.zero? ? 0 : rest - 1)
+        settle
+        underflows
+      end
+
       def enter
         @pipe = 0b10
         @empty = false

data/lib/badline/cia.rb

@@ -4,12 +4,14 @@ 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.

data/lib/badline/computer/attachments.rb

@@ -57,6 +57,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