badline 0.4.2 → 0.5.0

data/lib/badline/drive1541/disk.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require "badline/drive1541/sector_reader"
+
+module Badline
+  class Drive1541
+    # A disk as the head sees it: a Track for each half track that holds
+    # data, numbered from 2 (track 1) to MAX_HALF_TRACK (track 42), and
+    # nothing between them. A .d64 image fills the whole tracks; a .g64
+    # can fill any of them, with tracks of any length.
+    #
+    # 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
+    # since the last flush and stores them in the image, which writes its
+    # host file. The disk is write-protected when the image won't take
+    # writes.
+    class Disk
+      MAX_HALF_TRACK = 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
+
+      # The speed zone each track is written in: 3 for the 21 sectors of
+      # tracks 1-17, 2 for 18-24, 1 for 25-30 and 0 from 31 on.
+      def self.zone(track)
+        if track <= 17 then 3
+        elsif track <= 24 then 2
+        elsif track <= 30 then 1
+        else 0
+        end
+      end
+
+      # How far round the DOS's N: starts each track from the one before,
+      # in each zone, in 1/10000 of a turn: it steps in and starts writing
+      # the next track that long after it started the last.
+      SKEWS = [2916, 897, 8915, 6869].freeze
+      SKEW_TURN = 10_000
+
+      SYNC_LENGTH = 5
+      HEADER_GAP = 9
+      GAP = 0x55
+      HEADER_ID = 0x08
+      DATA_ID = 0x07
+
+      # A sector: SYNC, the 10-byte GCR header, the header gap, SYNC and
+      # 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.
+      def self.open(path, read_only: false)
+        return from_g64(Storage::G64Image.new(path, read_only:)) if File.extname(path).casecmp?(".g64")
+
+        from_d64(Storage::D64Image.new(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.
+      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
+          track = image.track(entry)
+          disk.write(half_track, Track.new(*track, image.speeds(entry))) if track
+        end
+        disk
+      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
+      # way that DOS error would read. The table's other codes, 24, 25, 26
+      # and 28, describe write or decoding faults the layout can't carry,
+      # so their blocks are written good and read without an error.
+      #
+      # 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.
+      def self.from_d64(image)
+        track, sector = image.header_block
+        header = image.read_block(track, sector)
+        id = [header[0xa2], header[0xa3]]
+        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)))
+        end
+        disk
+      end
+
+      def self.format_track(image, track, id)
+        sectors = image.sectors_in(track)
+        length = TRACK_LENGTHS[zone(track)]
+        gap = (length - (sectors * SECTOR_LENGTH)) / sectors
+        bytes = []
+        sectors.times do |sector|
+          format_sector(bytes, image, track, sector, id)
+          gap.times { bytes << GAP }
+        end
+        bytes << GAP while bytes.length < length
+        bytes
+      end
+
+      # Error 21 leaves the block without SYNC marks, and 29 writes its
+      # header with the wrong first ID byte.
+      def self.format_sector(bytes, image, track, sector, id)
+        error = image.block_error(track, sector)
+        sync = error == 21 ? GAP : 0xff
+        id = [id[0] ^ 0xff, id[1]] if error == 29
+        SYNC_LENGTH.times { bytes << sync }
+        bytes.concat(GCR.encode(header(track, sector, id, error)))
+        HEADER_GAP.times { bytes << GAP }
+        SYNC_LENGTH.times { bytes << sync }
+        bytes.concat(GCR.encode(data_block(image.read_block(track, sector), error)))
+      end
+
+      # ID, checksum, sector, track, the second ID byte, the first and two
+      # $0F fillers. Error 20 hides the block's ID and 27 spoils its
+      # checksum.
+      def self.header(track, sector, id, error)
+        checksum = sector ^ track ^ id[1] ^ id[0]
+        checksum ^= 0xff if error == 27
+        [error == 20 ? 0x00 : HEADER_ID, checksum, sector, track, id[1], id[0], 0x0f, 0x0f]
+      end
+
+      # ID, 256 data bytes, their checksum and two $00 fillers. Error 22
+      # hides the block's ID and 23 spoils its checksum.
+      def self.data_block(data, error)
+        checksum = 0
+        data.each { |byte| checksum ^= byte }
+        checksum ^= 0xff if error == 23
+        block = [error == 22 ? 0x00 : DATA_ID]
+        block.concat(data)
+        block << checksum << 0x00 << 0x00
+      end
+
+      attr_reader :image
+
+      def initialize(image = nil)
+        @image = image
+        @tracks = Array.new(MAX_HALF_TRACK + 1)
+        @written = {}
+      end
+
+      # The Track at the half track, or nil where there's no data.
+      def track(half_track) = @tracks[half_track]
+
+      def write(half_track, track)
+        @tracks[half_track] = track
+      end
+
+      # Whether the write-protect notch is covered: the disk's image won't
+      # take writes. A disk without an image takes them, and keeps them
+      # only in its tracks.
+      def write_protected? = !@image.nil? && !@image.writable?
+
+      # A half track the head writes to, blank to begin with: no flux, and
+      # as many bytes as a turn holds at the bit rate of the +zone+ it's
+      # written in.
+      def writable_track(half_track, zone)
+        @tracks[half_track] ||= Track.new(Array.new(TRACK_LENGTHS[zone], 0), zone)
+      end
+
+      # The head wrote to the half track.
+      def written(half_track)
+        @written[half_track] = true
+      end
+
+      # Whether any track was written since the last flush.
+      def written? = !@written.empty?
+
+      # Stores each track written since the last flush in the image, all
+      # in one write to its host file. A G64 image takes the tracks as they
+      # are. A D64 image takes the sectors read back off them, and keeps
+      # whole tracks only, so a half track, or a track past its last, stays
+      # on the disk alone. A sector that no longer reads back keeps its old
+      # data, and the flush warns once, naming the tracks that lost one.
+      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) }
+        @written.clear
+        return if tracks.empty?
+
+        sectors = tracks.to_h { |half| [half / 2, SectorReader.read(@tracks[half].bytes, half / 2)] }
+        id = disk_id(sectors)
+        warn_lost(sectors)
+        @image.store_blocks(sectors.flat_map do |track, found|
+          Array.new(@image.sectors_in(track)) { |sector| stored_block(track, sector, found[sector], id) }
+        end)
+      end
+
+      private
+
+      def flush_tracks
+        tracks = @written.keys.sort.to_h do |half|
+          [half - Mechanism::MIN_HALF_TRACK, [@tracks[half].bytes, @tracks[half].zone]]
+        end
+        @written.clear
+        @image.store_tracks(tracks) unless tracks.empty?
+      end
+
+      def warn_lost(sectors)
+        lost = sectors.keys.select do |track|
+          Array.new(@image.sectors_in(track)) { |sector| lost?(track, sector, sectors[track][sector]) }.any?
+        end
+        return if lost.empty?
+
+        warn "1541: tracks written that no longer read back whole: #{lost.join(', ')}. The .d64 keeps the old " \
+             "data of the sectors lost, and a .g64 image keeps tracks as the drive writes them."
+      end
+
+      # A sector the head no longer finds, which the image doesn't already
+      # hold as unreadable.
+      def lost?(track, sector, found)
+        found.nil? && ![20, 21].include?(@image.block_error(track, sector))
+      end
+
+      # The disk ID the headers must carry, from the header block's $A2 and
+      # $A3 as Disk.from_d64 takes it: as just read back, or as the image
+      # holds it.
+      def disk_id(sectors)
+        track, sector = @image.header_block
+        header = sectors.dig(track, sector)&.data
+        data = header ? header[1, 256] : @image.read_block(track, sector)
+        [data[0xa2], data[0xa3]]
+      end
+
+      # [track, sector, data, error] for DiskImage#store_blocks: the data as
+      # read, nil where it can't be, and the DOS error a read of it would
+      # raise, the way Disk.from_d64 writes each one. A sector whose header
+      # isn't found keeps its data, and reads as error 20, or 21 where the
+      # image already has it so.
+      def stored_block(track, sector, found, id)
+        return [track, sector, nil, @image.block_error(track, sector) == 21 ? 21 : 20] unless found
+
+        header = found.header
+        data = found.data
+        [track, sector, data && data[1, 256], block_error(header, data, id)]
+      end
+
+      def block_error(header, data, id)
+        if header[1] != header[2] ^ header[3] ^ header[4] ^ header[5] then 27
+        elsif header[5] != id[0] || header[4] != id[1] then 29
+        elsif data.nil? || data[0] != DATA_ID then 22
+        elsif data[257] != data[1, 256].reduce(:^) then 23
+        end
+      end
+    end
+  end
+end

data/lib/badline/drive1541/disk_via.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    # VIA 2, the one facing the disk mechanism. Its port B drives the
+    # Mechanism, and CB2 selects its read or write mode. The mechanism
+    # hears both after every write and reset, since ORB, DDRB, the ACR and
+    # the PCR can all change them.
+    class DiskVIA < VIA
+      def initialize(start:, mechanism:)
+        @mechanism = mechanism
+        super(start:, peripheral: mechanism)
+      end
+
+      def reset!
+        super
+        tell_mechanism
+      end
+
+      def poke(addr, value)
+        super
+        tell_mechanism
+      end
+
+      private
+
+      def tell_mechanism
+        @mechanism.port_b_written(port_b_output)
+        @mechanism.cb2_written(cb2_output)
+      end
+    end
+  end
+end

data/lib/badline/drive1541/gcr.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    # Group code recording, the 1541's on-disk code. Each nibble becomes
+    # five bits, chosen so that no code has more than two 0 bits in a row
+    # and no run of codes has ten 1 bits in a row, which only a SYNC mark
+    # has. Four bytes become five.
+    module GCR
+      CODES = [0x0a, 0x0b, 0x12, 0x13, 0x0e, 0x0f, 0x16, 0x17,
+               0x09, 0x19, 0x1a, 0x1b, 0x0d, 0x1d, 0x1e, 0x15].freeze
+
+      # Five-bit code => nibble, nil for the codes that aren't GCR.
+      NIBBLES = Array.new(32) { |code| CODES.index(code) }.freeze
+
+      module_function
+
+      # Encodes a whole number of four-byte groups.
+      def encode(bytes)
+        out = []
+        i = 0
+        while i < bytes.length
+          bits = 0
+          4.times do |n|
+            byte = bytes[i + n]
+            bits = (bits << 10) | (CODES[byte >> 4] << 5) | CODES[byte & 0x0f]
+          end
+          4.downto(0) { |n| out << ((bits >> (n * 8)) & 0xff) }
+          i += 4
+        end
+        out
+      end
+
+      # Decodes a whole number of five-byte groups, nil when any code
+      # isn't GCR.
+      def decode(bytes)
+        out = []
+        i = 0
+        while i < bytes.length
+          bits = 0
+          5.times { |n| bits = (bits << 8) | bytes[i + n] }
+          n = 7
+          while n.positive?
+            high = NIBBLES[(bits >> (n * 5)) & 0x1f]
+            low = NIBBLES[(bits >> ((n - 1) * 5)) & 0x1f]
+            return nil if high.nil? || low.nil?
+
+            out << ((high << 4) | low)
+            n -= 2
+          end
+          i += 5
+        end
+        out
+      end
+    end
+  end
+end

data/lib/badline/drive1541/idle.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    # 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.
+    #
+    # Each time the CPU comes to $EBFF, the drive records the pass that
+    # follows. At the next $EBFF 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. 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
+    # 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 $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.
+    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
+
+      def idle_skip=(on)
+        settle!
+        @idle_skip = on
+      end
+
+      # 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, since whoever called may change it. Every
+      # reader of the drive's parts calls this.
+      def settle!
+        if @asleep
+          wake!
+          @serial_port.latch_host
+        end
+        stop_recording if @recording
+      end
+
+      private
+
+      # A host cycle asleep.
+      def doze
+        @slept += 1
+        settle! if @slept == @wake_at || @serial_port.atn_moved?
+      end
+
+      def init_idle(debug)
+        @idle_skip = !debug
+        @asleep = false
+        @recording = false
+        @owed = 0
+        @budget = 0
+        @slept = 0
+        @wake_at = 0
+        @pass_cycles = 0
+        @pass_instructions = 0
+      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.
+      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 @mechanism.motor_on? || @via1.irq? || @via2.irq? || @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
+        @owed = 0
+        @budget = quiet_cycles
+      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.
+      def plan_wake
+        @slept = 0
+        needed = ((@budget - @owed) * @host_clock_hz) - @phase
+        @wake_at = needed.positive? ? (needed + CLOCK_HZ - 1) / CLOCK_HZ : 1
+      end
+
+      # Runs the cycles owed: whole passes in bulk, up to the budget, and
+      # the rest one by one.
+      def wake!
+        @asleep = false
+        phase = @phase + (@slept * CLOCK_HZ)
+        @phase = phase % @host_clock_hz
+        owed = @owed + (phase / @host_clock_hz)
+        @owed = 0
+        @slept = 0
+        span = [owed, @budget].min
+        passes = span / @pass_cycles
+        if passes.positive?
+          cycles = passes * @pass_cycles
+          @cpu.fast_forward(cycles, passes * @pass_instructions)
+          @via1.fast_forward(cycles)
+          @via2.fast_forward(cycles)
+          @cycles += cycles
+          owed -= cycles
+        end
+        owed.times { step }
+      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