badline 0.10.1 → 0.11.1

data/lib/badline/drive/watch.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drive
+    # A drive bus's eye on what the CPU reaches, for Idle and Orbit. While
+    # Idle records a pass of the DOS's idle loop, the bus watches it (see
+    # watch!). While Idle looks for an orbit, the bus guards the drive
+    # (see guard!). The bus calls watch_read and watch_write with the
+    # address folded into $0000-$1FFF, RAM and the two VIAs at $1800 and
+    # $1C00, while @watching.
+    module Watch
+      # VIA registers, as bits by offset, whose access makes a watched
+      # stretch volatile: reads of either VIA's counters and shift register
+      # and of VIA 1's port B, and writes to VIA 2's timers, shift register
+      # and ACR. Any write to VIA 1 does too (watch_write).
+      VOLATILE_VIA1_READS = 0x0731
+      VOLATILE_VIA2_READS = 0x0730
+      VOLATILE_VIA2_WRITES = 0x0ff0
+
+      # The timer each VIA register reaches, by offset, as bits: 1 for
+      # timer 1 and 2 for timer 2.
+      TIMER_REGISTERS = [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 0, 0, 0, 0, 0, 0].freeze
+
+      # Whether a watched stretch did something that makes it unrepeatable.
+      attr_reader :volatile
+
+      # The RAM a watched stretch read or wrote, as each address's value
+      # from before the first access.
+      attr_reader :touched
+
+      # Whether the drive did something since guard! that reached outside
+      # it, or took something in from outside.
+      attr_reader :tainted
+
+      # The timers the drive read or wrote since guard!, as bits: VIA 1's
+      # timer 1 and timer 2 in bits 0 and 1, and VIA 2's in bits 2 and 3.
+      attr_reader :touched_timers
+
+      # Starts watching: see volatile and touched. The bus stops watching
+      # once the stretch turns volatile.
+      def watch!
+        @recording = true
+        @volatile = false
+        @touched = {}
+        watching!
+      end
+
+      def unwatch!
+        @recording = false
+        watching!
+      end
+
+      # Starts guarding: see tainted and touched_timers. Reading VIA 1's
+      # port B, which reads the serial bus, taints the drive, and so do
+      # any write to VIA 1, whose port B drives the serial bus, a write to
+      # VIA 2's shift register or ACR, and VIA 2 turning the motor on or
+      # changing the LED. The bus stops guarding once the drive is tainted.
+      def guard!
+        @guarding = true
+        @tainted = false
+        @touched_timers = 0
+        @led = @via2.port_b_output & Drive1541::Mechanism::LED
+        watching!
+      end
+
+      private
+
+      def init_watch
+        @recording = @guarding = @watching = false
+        @volatile = @tainted = false
+        @touched = {}
+        @touched_timers = 0
+        @led = 0
+      end
+
+      def watching!
+        @watching = @recording || @guarding
+      end
+
+      # An access to a chip beyond the VIAs, as the 1571's CIA and floppy
+      # controller are: it makes the stretch volatile and taints the
+      # drive.
+      def watch_chip
+        volatile! if @recording
+        taint! if @guarding
+      end
+
+      def touch(addr)
+        @touched[addr] = @ram.peek(addr) unless @touched.key?(addr)
+      end
+
+      def watch_read(addr)
+        if addr < 0x0800
+          touch(addr) if @recording
+        elsif addr >= 0x1800
+          via1 = addr < 0x1c00
+          watch(via1 ? VOLATILE_VIA1_READS : VOLATILE_VIA2_READS, addr) if @recording
+          guard_read(via1, addr & 0x0f) if @guarding
+        end
+      end
+
+      def watch_write(addr)
+        if addr >= 0x1c00
+          watch_via2_write(addr) if @recording
+          guard_via2_write(addr & 0x0f) if @guarding
+        elsif addr >= 0x1800
+          volatile! if @recording
+          taint! if @guarding
+        end
+      end
+
+      # Any write to VIA 1 makes the stretch volatile (watch_write), and so
+      # does a write to VIA 2 that leaves the motor on.
+      def watch_via2_write(addr)
+        watch(VOLATILE_VIA2_WRITES, addr)
+        volatile! if @recording && @via2.port_b_output.anybits?(Drive1541::Mechanism::MOTOR)
+      end
+
+      def watch(volatile, addr)
+        volatile! if volatile.anybits?(1 << (addr & 0x0f))
+      end
+
+      def volatile!
+        @volatile = true
+        @recording = false
+        watching!
+      end
+
+      def guard_read(via1, offset)
+        return taint! if via1 && offset.zero?
+
+        @touched_timers |= via1 ? TIMER_REGISTERS[offset] : TIMER_REGISTERS[offset] << 2
+      end
+
+      def guard_via2_write(offset)
+        return taint! if offset.between?(0x0a, 0x0b)
+
+        @touched_timers |= TIMER_REGISTERS[offset] << 2
+        lines = @via2.port_b_output
+        taint! if lines.anybits?(Drive1541::Mechanism::MOTOR) || (lines & Drive1541::Mechanism::LED) != @led
+      end
+
+      def taint!
+        @tainted = true
+        @guarding = false
+        watching!
+      end
+    end
+  end
+end

data/lib/badline/drive.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "badline/drive/sleep"
+require "badline/drive/idle"
+require "badline/drive/orbit"
+require "badline/drive/core"
+require "badline/drive/idle_cpu"
+require "badline/drive/watch"
+require "badline/drive/serial_lines"

data/lib/badline/drive1541/bus.rb

@@ -18,41 +18,15 @@ module Badline
     # page is what its dummy read found. VICE-testprogs drive/openbus pins
     # both on a real 1541.
     #
-    # While Idle records a pass of the DOS's idle loop, the bus watches it
-    # (see watch!). While Idle looks for an orbit, the bus guards the drive
-    # (see guard!).
+    # While Idle records a pass of the DOS's idle loop, the bus watches it,
+    # and while Idle looks for an orbit, it guards the drive (see
+    # Drive::Watch).
     class Bus
       include Addressable
-
-      # VIA registers, as bits by offset, whose access makes a watched
-      # stretch volatile: reads of either VIA's counters and shift register
-      # and of VIA 1's port B, and writes to VIA 2's timers, shift register
-      # and ACR. Any write to VIA 1 does too (watch_write).
-      VOLATILE_VIA1_READS = 0x0731
-      VOLATILE_VIA2_READS = 0x0730
-      VOLATILE_VIA2_WRITES = 0x0ff0
-
-      # The timer each VIA register reaches, by offset, as bits: 1 for
-      # timer 1 and 2 for timer 2.
-      TIMER_REGISTERS = [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 0, 0, 0, 0, 0, 0].freeze
+      include Drive::Watch
 
       attr_reader :ram, :rom, :via1, :via2, :data
 
-      # Whether a watched stretch did something that makes it unrepeatable.
-      attr_reader :volatile
-
-      # The RAM a watched stretch read or wrote, as each address's value
-      # from before the first access.
-      attr_reader :touched
-
-      # Whether the drive did something since guard! that reached outside
-      # it, or took something in from outside.
-      attr_reader :tainted
-
-      # The timers the drive read or wrote since guard!, as bits: VIA 1's
-      # timer 1 and timer 2 in bits 0 and 1, and VIA 2's in bits 2 and 3.
-      attr_reader :touched_timers
-
       def initialize(rom:, via1:, via2:)
         addressable_at(0, length: 2**16)
         @ram = Memory.new([], length: 0x0800, start: 0)
@@ -60,38 +34,7 @@ module Badline
         @via1 = via1
         @via2 = via2
         @data = 0
-        @recording = @guarding = @watching = false
-        @volatile = @tainted = false
-        @touched = {}
-        @touched_timers = 0
-        @led = 0
-      end
-
-      # Starts watching: see volatile and touched. The bus stops watching
-      # once the stretch turns volatile.
-      def watch!
-        @recording = true
-        @volatile = false
-        @touched = {}
-        watching!
-      end
-
-      def unwatch!
-        @recording = false
-        watching!
-      end
-
-      # Starts guarding: see tainted and touched_timers. Reading VIA 1's
-      # port B, which reads the serial bus, taints the drive, and so do
-      # any write to VIA 1, whose port B drives the serial bus, a write to
-      # VIA 2's shift register or ACR, and VIA 2 turning the motor on or
-      # changing the LED. The bus stops guarding once the drive is tainted.
-      def guard!
-        @guarding = true
-        @tainted = false
-        @touched_timers = 0
-        @led = @via2.port_b_output & Mechanism::LED
-        watching!
+        init_watch
       end
 
       # The last byte on the data bus and the RAM. What a watched stretch
@@ -138,73 +81,6 @@ module Badline
         end
         watch_write(addr) if @watching
       end
-
-      private
-
-      def watching!
-        @watching = @recording || @guarding
-      end
-
-      def touch(addr)
-        @touched[addr] = @ram.peek(addr) unless @touched.key?(addr)
-      end
-
-      def watch_read(addr)
-        if addr < 0x0800
-          touch(addr) if @recording
-        elsif addr >= 0x1800
-          via1 = addr < 0x1c00
-          watch(via1 ? VOLATILE_VIA1_READS : VOLATILE_VIA2_READS, addr) if @recording
-          guard_read(via1, addr & 0x0f) if @guarding
-        end
-      end
-
-      def watch_write(addr)
-        if addr >= 0x1c00
-          watch_via2_write(addr) if @recording
-          guard_via2_write(addr & 0x0f) if @guarding
-        elsif addr >= 0x1800
-          volatile! if @recording
-          taint! if @guarding
-        end
-      end
-
-      # Any write to VIA 1 makes the stretch volatile (watch_write), and so
-      # does a write to VIA 2 that leaves the motor on.
-      def watch_via2_write(addr)
-        watch(VOLATILE_VIA2_WRITES, addr)
-        volatile! if @recording && @via2.port_b_output.anybits?(Mechanism::MOTOR)
-      end
-
-      def watch(volatile, addr)
-        volatile! if volatile.anybits?(1 << (addr & 0x0f))
-      end
-
-      def volatile!
-        @volatile = true
-        @recording = false
-        watching!
-      end
-
-      def guard_read(via1, offset)
-        return taint! if via1 && offset.zero?
-
-        @touched_timers |= via1 ? TIMER_REGISTERS[offset] : TIMER_REGISTERS[offset] << 2
-      end
-
-      def guard_via2_write(offset)
-        return taint! if offset.between?(0x0a, 0x0b)
-
-        @touched_timers |= TIMER_REGISTERS[offset] << 2
-        lines = @via2.port_b_output
-        taint! if lines.anybits?(Mechanism::MOTOR) || (lines & Mechanism::LED) != @led
-      end
-
-      def taint!
-        @tainted = true
-        @guarding = false
-        watching!
-      end
     end
   end
 end

data/lib/badline/drive1541/byte_ready.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    # The Mechanism's BYTE READY line: to VIA 2's CA1, to the CPU's SO pin
+    # through SOE, and on the 1571 to a latch VIA 1's PA7 reads.
+    module ByteReady
+      # VIA 2, which DiskVIA plugs in.
+      attr_writer :via
+
+      # Whether BYTE READY reached SO for the CPU to sample on the drive's
+      # next cycle.
+      attr_accessor :so_pending
+
+      # Whether SO is pending, which the drive's cycle samples and clears.
+      def take_so
+        so = @so_pending
+        @so_pending = false
+        so
+      end
+
+      # The read electronics signal a whole GCR byte. BYTE READY pulls VIA
+      # 2's CA1 low, a falling edge that sets its flag and, with latching
+      # on, latches port A. It reaches the CPU's SO pin while VIA 2's CA2
+      # (SOE) is high, which lets the DOS spin on BVC for each byte. The CPU
+      # samples SO on the next cycle.
+      def byte_ready!
+        @byte_latched = true
+        @via.ca1 = false
+        @so_pending = true if @via.ca2_output
+      end
+
+      # BYTE READY lets go of CA1 with the next bit.
+      def byte_ready_ended!
+        @via.ca1 = true
+      end
+
+      # Whether BYTE READY has come since the CPU last read VIA 2, as the
+      # 1571 latches it for VIA 1's PA7.
+      def byte_latched? = @byte_latched
+
+      # A read of VIA 2 clears the 1571's BYTE READY latch.
+      def release_byte_latch
+        @byte_latched = false
+      end
+    end
+  end
+end

data/lib/badline/drive1541/cpu.rb

@@ -5,25 +5,7 @@ module Badline
     # The drive's 6502, on the drive's Bus.
     class CPU
       include Badline::CPU::Core
-
-      # 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. Drive1541::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
+      include Drive::IdleCPU
     end
   end
 end

data/lib/badline/drive1541/disk.rb

@@ -10,6 +10,11 @@ module Badline
     # nothing between them. A .d64 image fills the whole tracks; a .g64
     # can fill any of them, with tracks of any length.
     #
+    # The disk has a second side, for the 1571's second head, its half
+    # tracks numbered from SIDE on. A .d71 fills both sides, its tracks
+    # 36-70 being tracks 1-35 of the second, and a .g71 holds 84 half
+    # tracks a side. A 1541 reads the first side only.
+    #
     # The head writes into the tracks' bytes, and a write to a half track
     # without data gives it a blank Track first. A disk made from an image
     # remembers it: flush reads the sectors back off the tracks written
@@ -21,6 +26,15 @@ module Badline
 
       MAX_HALF_TRACK = 84
 
+      # Where the second side's half tracks start: its track 1 is SIDE + 2.
+      SIDE = MAX_HALF_TRACK + 1
+
+      # The tracks a side of a .d71 holds.
+      D71_SIDE_TRACKS = 35
+
+      # The half track entries a side of a .g71 holds.
+      G71_SIDE_ENTRIES = 84
+
       # GCR bytes around a track in each speed zone: 200 ms of rotation at
       # 300 rpm, in bytes of 32, 30, 28 and 26 µs.
       TRACK_LENGTHS = [6250, 6666, 7142, 7692].freeze
@@ -51,27 +65,63 @@ module Badline
       # the 325-byte GCR data block. The gap after it takes up the rest.
       SECTOR_LENGTH = SYNC_LENGTH + 10 + HEADER_GAP + SYNC_LENGTH + 325
 
-      # A disk from the image at +path+: a .g64 as its tracks are, and
-      # anything else as a .d64, formatted. `read_only` opens the image
-      # write-protected.
+      # A disk from the image at +path+: a .g64 or .g71 as its tracks are,
+      # a .d71 formatted on both sides, and anything else as a .d64,
+      # formatted. `read_only` opens the image write-protected.
       def self.open(path, read_only: false)
         return from_g64(Storage::G64Image.new(path, read_only:)).opened(path, read_only) if State.g64?(path)
+        return from_d64(Storage::D71Image.new(path, read_only:)).opened(path, read_only) if State.d71?(path)
 
         from_d64(Storage::D64Image.new(path, read_only:)).opened(path, read_only)
       end
 
-      # A disk from a G64 image, each half track as the image stores it,
-      # with its speed map. Flushing it writes the tracks back as they are.
+      # A disk from a G64 or G71 image, each half track as the image stores
+      # it, with its speed map. Flushing it writes the tracks back as they
+      # are.
       def self.from_g64(image)
         disk = new(image)
-        (Mechanism::MIN_HALF_TRACK..MAX_HALF_TRACK).each do |half_track|
-          entry = half_track - Mechanism::MIN_HALF_TRACK
+        image.half_tracks.times do |entry|
           track = image.track(entry)
-          disk.write(half_track, Track.new(*track, image.speeds(entry))) if track
+          disk.write(half_track_of(entry), Track.new(*track, image.speeds(entry))) if track
         end
         disk
       end
 
+      # The half track a G64 or G71 table entry holds: entry 0 is track 1,
+      # and a .g71's entries from G71_SIDE_ENTRIES on are the second
+      # side's.
+      def self.half_track_of(entry)
+        side = entry / G71_SIDE_ENTRIES
+        (side * SIDE) + (entry % G71_SIDE_ENTRIES) + Mechanism::MIN_HALF_TRACK
+      end
+
+      # The table entry of a half track, or nil for one a G64 or G71 has
+      # no entry for.
+      def self.entry_of(half_track)
+        side = half_track / SIDE
+        entry = (half_track % SIDE) - Mechanism::MIN_HALF_TRACK
+        (side * G71_SIDE_ENTRIES) + entry if entry.between?(0, G71_SIDE_ENTRIES - 1)
+      end
+
+      # The half track an image's track number is on: a .d71's tracks past
+      # D71_SIDE_TRACKS are on the second side.
+      def self.d64_half_track(image, track)
+        return track * 2 unless image.sides == 2 && track > D71_SIDE_TRACKS
+
+        SIDE + ((track - D71_SIDE_TRACKS) * 2)
+      end
+
+      # The image's track number a half track holds, or nil for a half
+      # track or one past the image's last.
+      def self.d64_track(image, half_track)
+        side = half_track / SIDE
+        return unless (half_track % SIDE).even?
+
+        track = (half_track % SIDE) / 2
+        track += D71_SIDE_TRACKS if side == 1
+        track if track.positive? && track <= image.track_count && side < image.sides
+      end
+
       # A disk formatted from a D64 image, each sector laid out as the DOS
       # formats it, with the disk ID from the header block. A block the
       # image's error table marks 20, 21, 22, 23, 27 or 29 is written the
@@ -81,7 +131,8 @@ module Badline
       #
       # Each track starts sector 0 at the angle the DOS's N: leaves it: track
       # 1 at the index angle, and each track after it SKEWS[zone] of a turn
-      # round from the last.
+      # round from the last. A .d71's second side starts over at the index
+      # angle.
       def self.from_d64(image)
         track, sector = image.header_block
         header = image.read_block(track, sector)
@@ -89,16 +140,18 @@ module Badline
         disk = new(image)
         angle = 0
         (1..image.track_count).each do |track|
-          angle = (angle + SKEWS[zone(track)]) % SKEW_TURN if track > 1
-          bytes = format_track(image, track, id)
-          disk.write(track * 2, Track.new(bytes.rotate(-(bytes.length * angle / SKEW_TURN)), zone(track)))
+          half_track = d64_half_track(image, track)
+          zone = zone((half_track % SIDE) / 2)
+          angle = half_track == SIDE + 2 ? 0 : (angle + SKEWS[zone]) % SKEW_TURN if track > 1
+          bytes = format_track(image, track, id, zone)
+          disk.write(half_track, Track.new(bytes.rotate(-(bytes.length * angle / SKEW_TURN)), zone))
         end
         disk
       end
 
-      def self.format_track(image, track, id)
+      def self.format_track(image, track, id, zone = zone(track))
         sectors = image.sectors_in(track)
-        length = TRACK_LENGTHS[zone(track)]
+        length = TRACK_LENGTHS[zone]
         gap = (length - (sectors * SECTOR_LENGTH)) / sectors
         bytes = []
         sectors.times do |sector|
@@ -146,7 +199,7 @@ module Badline
 
       def initialize(image = nil)
         @image = image
-        @tracks = Array.new(MAX_HALF_TRACK + 1)
+        @tracks = Array.new(SIDE * 2)
         @written = {}
         @path = nil
         @read_only = false
@@ -188,11 +241,14 @@ module Badline
       def flush
         return flush_tracks if @image.respond_to?(:store_tracks)
 
-        tracks = @written.keys.select { |half| half.even? && (1..@image&.track_count.to_i).cover?(half / 2) }
+        tracks = @written.keys.filter_map do |half|
+          track = @image && Disk.d64_track(@image, half)
+          [half, track] if track
+        end
         @written.clear
         return if tracks.empty?
 
-        sectors = tracks.to_h { |half| [half / 2, SectorReader.read(@tracks[half].bytes, half / 2)] }
+        sectors = tracks.to_h { |half, track| [track, SectorReader.read(@tracks[half].bytes, track)] }
         id = disk_id(sectors)
         warn_lost(sectors)
         @image.store_blocks(sectors.flat_map do |track, found|
@@ -203,9 +259,10 @@ module Badline
       private
 
       def flush_tracks
-        tracks = @written.keys.sort.to_h do |half|
-          [half - Mechanism::MIN_HALF_TRACK, [@tracks[half].bytes, @tracks[half].zone]]
-        end
+        tracks = @written.keys.sort.filter_map do |half|
+          entry = Disk.entry_of(half)
+          [entry, [@tracks[half].bytes, @tracks[half].zone]] if entry
+        end.to_h
         @written.clear
         @image.store_tracks(tracks) unless tracks.empty?
       end

data/lib/badline/drive1541/disk_state.rb

@@ -12,13 +12,18 @@ module Badline
         # for a disk from Disk.open. Nil for a disk made another way.
         attr_reader :path, :read_only
 
-        # A .g64 image by its name, and anything else a .d64.
-        def self.g64?(path) = File.extname(path).casecmp?(".g64")
+        # A .g64 or .g71 image by its name, a .d71 by its name, and anything
+        # else a .d64.
+        def self.g64?(path) = %w[.g64 .g71].include?(File.extname(path).downcase)
+
+        def self.d71?(path) = File.extname(path).casecmp?(".d71")
 
         # A disk for the image at the path, its tracks left for the state.
         def self.reopen(path, read_only)
           if g64?(path)
             Disk.new(Storage::G64Image.new(path, read_only:)).opened(path, read_only)
+          elsif d71?(path)
+            Disk.new(Storage::D71Image.new(path, read_only:)).opened(path, read_only)
           else
             Disk.new(Storage::D64Image.new(path, read_only:)).opened(path, read_only)
           end

data/lib/badline/drive1541/disk_via.rb

@@ -7,8 +7,11 @@ module Badline
     # hears both after every write and reset, since ORB, DDRB, the ACR and
     # the PCR can all change them.
     class DiskVIA < VIA
+      attr_reader :mechanism
+
       def initialize(start:, mechanism:)
         @mechanism = mechanism
+        mechanism.via = self
         super(start:, peripheral: mechanism)
       end