badline 0.12.1 → 0.14.0

data/lib/badline/drive1541/disk_state.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/media/extensions"
-
-module Badline
-  class Drive1541
-    class Disk
-      # Saving and restoring a Disk for a snapshot: the image by its path,
-      # and every half track as the head sees it, with those written since
-      # the last flush. The image itself is read again from its host file,
-      # where there still is one.
-      module State
-        # The image's path, expanded, and whether it was opened read-only,
-        # for a disk from Disk.open. Nil for a disk made another way.
-        attr_reader :path, :read_only
-
-        # Whether the image is a .g64 or .g71, by its name.
-        def self.g64?(path) = Media::Extensions.kind(path) == :gcr
-
-        # A disk for the image at the path (Disk.image_for), its tracks left
-        # for the state.
-        def self.reopen(path, read_only) = Disk.new(Disk.image_for(path, read_only)).opened(path, read_only)
-
-        # The disk a state from save_state describes: +current+ when it was
-        # opened from the same image the same way, and otherwise a disk for
-        # the image at the path the state names. Where no file is at that
-        # path, the disk has no image and is write-protected, and a
-        # detached reader always gets one without an image. Either way its
-        # tracks come from the state.
-        def self.load(input, current)
-          path = input.optional_string
-          read_only = input.boolean?
-          disk = current if current && !path.nil? && current.path == path && current.read_only == read_only
-          disk ||= fresh(path, read_only, input.detached?)
-          disk.load_tracks(input)
-          disk
-        end
-
-        def self.fresh(path, read_only, detached)
-          return Disk.new if path.nil? || detached
-          return Disk.new.opened(path, true) unless File.file?(path)
-
-          reopen(path, read_only)
-        end
-
-        # Notes the image's path and how it was opened.
-        def opened(path, read_only)
-          @path = File.expand_path(path)
-          @read_only = read_only
-          self
-        end
-
-        def save_state(out)
-          out.optional_string(@path).boolean(@read_only)
-          @tracks.each do |track|
-            out.boolean(!track.nil?)
-            save_track(track, out) if track
-          end
-          out.ints(@written.keys)
-        end
-
-        def load_tracks(input)
-          @tracks.each_index do |half_track|
-            @tracks[half_track] = input.boolean? ? load_track(input) : nil
-          end
-          @written.clear
-          input.ints.each { |half_track| @written[half_track] = true }
-        end
-
-        private
-
-        def save_track(track, out)
-          out.int(track.zone).boolean(!track.speeds.nil?)
-          out.ints(track.speeds) if track.speeds
-          out.blob(track.bytes)
-        end
-
-        def load_track(input)
-          zone = input.int
-          speeds = input.boolean? ? input.ints : nil
-          Track.new(input.blob, zone, speeds)
-        end
-      end
-    end
-  end
-end

data/lib/badline/drive1541/disk_via.rb

@@ -1,36 +0,0 @@
-# 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
-      attr_reader :mechanism
-
-      def initialize(start:, mechanism:)
-        @mechanism = mechanism
-        mechanism.via = self
-        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

@@ -1,57 +0,0 @@
-# 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/mechanism.rb

@@ -1,313 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/drive1541/rotation"
-require "badline/drive1541/mechanism_state"
-require "badline/drive1541/byte_ready"
-
-module Badline
-  class Drive1541
-    # The disk mechanism behind VIA 2: the spindle motor, the head on its
-    # stepper, the LED, the read and write electronics and the
-    # write-protect sensor.
-    #
-    # Port B drives it and reads it back:
-    #
-    #   PB0-1  stepper phase (out)    PB4    write protect (in, 1 = writable)
-    #   PB2    motor on (out)         PB5-6  bit rate, speed zone 0-3 (out)
-    #   PB3    LED on (out)           PB7    SYNC (in, 0 while in a SYNC mark)
-    #
-    # Port A reads the read shift register's low eight bits, which CA1
-    # latches on BYTE READY. In write mode it drives the write shift
-    # register, and the read shift register takes the bits written.
-    #
-    # The disk turns at 300 rpm under the head, and a read clock at the
-    # bit rate PB5-6 select clocks the bits off it (see Rotation).
-    #
-    # Ten 1 bits in a row are a SYNC mark while CB2 selects reading: PB7
-    # reads it, and it holds the bit counter at zero, so the first 0 bit
-    # after it starts a byte. Every eighth bit after that is BYTE READY,
-    # which pulls VIA 2's CA1 low until the next bit and reaches the CPU's
-    # SO pin (see byte_ready!).
-    #
-    # CB2 low selects write mode, where SYNC detection and the flux are
-    # off and the clock runs on at the selected rate. At each BYTE READY
-    # the write shift register loads what the VIA drives on port A, and
-    # the next eight clocks put that byte's bits on the track, most
-    # significant first, in place of what it held. While reading, the load
-    # takes the byte just read, so a switch to writing mid-byte writes the
-    # rest of it. A write lays its bits one to a cell from the cell under
-    # the head, so on a track written at the selected rate each bit fills
-    # the cell it passes over. A write to a half track without data gives
-    # it a blank track first, a turn long at the selected rate, and a
-    # write to a track written at another rate lays the whole track out
-    # again as a turn at the selected rate first (Track#relaid).
-    #
-    # PB4 reads the write-protect sensor: high with no disk in, or with
-    # the notch of a writable one open. With the disk write-protected the
-    # write gate stays shut: the bits and BYTE READY go on, and nothing
-    # reaches the disk. The DOS reads PB4 first and refuses to write, so
-    # only a program that writes without asking finds that out.
-    #
-    # The motor stopping flushes what was written to the disk's image
-    # (see Disk#flush), which is when the DOS is done with a job, and so
-    # does taking the disk out.
-    #
-    # The stepper moves the head a half track each time the phase steps
-    # by one, inwards for +1 and outwards for -1. Each half track has a
-    # phase of its own, from power-on the low two bits of its number, so
-    # the head sits on a whole track when phase 0 or 2 holds it. The
-    # stepper's coils are powered only while PB2 runs the motor, as VICE
-    # reads the 1541's schematic, so a phase set with the motor off moves
-    # nothing until the motor comes on and it pulls the head. Tracks run
-    # from half track 2 (track 1), where the head stops against the end of
-    # its rail, to Disk::MAX_HALF_TRACK. A step out against the stop slips:
-    # the head stays on track 1 and the phase that tried to pull it out
-    # becomes track 1's, so the DOS's bump leaves the head on track 1 in
-    # line with the phase it ends on, and its first step in reaches the
-    # half track after it.
-    #
-    # The 1571's stepper is lined up so that phase 0 holds track 1, where
-    # its track 0 sensor looks for the head (Mechanism.new's +slip+).
-    class Mechanism
-      include Rotation
-      include MechanismState
-      include ByteReady
-
-      MOTOR = 0x04
-      LED = 0x08
-      WRITE_PROTECT = 0x10
-      SYNC = 0x80
-
-      MIN_HALF_TRACK = 2
-      # Where the head sits at power-on: track 18, the directory.
-      START_HALF_TRACK = 36
-
-      SYNC_BITS = 10
-
-      attr_reader :disk, :half_track, :zone
-
-      # +slip+ is the stepper's phase offset at power-on: 0, where each half
-      # track's phase is the low two bits of its number, or 2 for track 1
-      # on phase 0.
-      def initialize(slip: 0)
-        @via = nil
-        @so_pending = false
-        @disk = nil
-        @half_track = START_HALF_TRACK
-        @slip = slip
-        @motor = false
-        @led = false
-        @zone = 0
-        @clock = Track.cell(0)
-        @time = 0
-        @clock_at = @clock / 2
-        @clocks = 0
-        @shift = 0
-        @ones = 0
-        @bits = 0
-        @sync = false
-        @byte_ready = false
-        @byte_latched = false
-        @writing = false
-        @write_shift = 0
-        @write_gate = false
-        @protected = false
-        @side_base = 0
-        @cycle_ticks = CYCLE
-        load_track
-      end
-
-      # The drive's clock rate: the disk turns on by fewer ticks each
-      # cycle at 2 MHz.
-      def clock_hz=(clock_hz)
-        @cycle_ticks = CYCLE * Drive1541::CLOCK_HZ / clock_hz
-      end
-
-      # The head that reads, 0 or 1, on a drive with two (Disk::SIDE).
-      def side = @side_base.zero? ? 0 : 1
-
-      def side=(side)
-        side_base = side * Disk::SIDE
-        return if side_base == @side_base
-
-        @side_base = side_base
-        load_track
-      end
-
-      def motor_on? = @motor
-
-      def led_on? = @led
-
-      def sync? = @sync
-
-      def writing? = @writing
-
-      # What port B and CB2 can change with the motor off: the motor, the
-      # LED, the zone and the clock's rate, the stepper, write mode and
-      # where a write starts, and the track and cell under the head. The
-      # rest moves only while the motor turns, or as a disk goes in (see
-      # Drive::Idle).
-      def idle_state
-        [@motor, @led, @zone, @clock, @half_track, @slip, @side_base, @disk, @track, @index, @mask, @cell_end,
-         @time, @writing, @write_index, @sync, @byte_latched]
-      end
-
-      # Puts a Disk in, or takes it out with nil, flushing the disk that
-      # was in. The head goes on from the same point in the turn.
-      def insert(disk)
-        flush
-        @disk = disk
-        @protected = disk&.write_protected? || false
-        @write_gate = !disk.nil? && !@protected
-        load_track
-      end
-
-      # Stores what the head wrote in the disk's image.
-      def flush
-        @disk.flush if @disk&.written?
-      rescue Storage::WriteError => e
-        warn "1541: couldn't write the disk back: #{e.message}"
-      end
-
-      # VIA 2 drives CB2 to +high+: low selects write mode, which stops
-      # SYNC detection at once.
-      def cb2_written(high)
-        @write_index = nil if high || !@writing
-        @writing = !high
-        @sync = !@writing && @ones >= SYNC_BITS
-      end
-
-      # VIA 2 drives port B's lines to +lines+.
-      def port_b_written(lines)
-        motor = @motor
-        @motor = lines.anybits?(MOTOR)
-        flush if motor && !@motor
-        @led = lines.anybits?(LED)
-        zone = (lines >> 5) & 0x03
-        if zone != @zone
-          @zone = zone
-          @clock = Track.cell(zone)
-          @track_written = false
-        end
-        step(lines & 0x03) if @motor
-      end
-
-      # Port A is the read shift register.
-      def read_a(_lines) = @shift & 0xff
-
-      # SYNC low in a SYNC mark, and write protect low for a protected
-      # disk.
-      def read_b(_lines)
-        lines = @sync ? 0xff & ~SYNC : 0xff
-        @protected ? lines & ~WRITE_PROTECT : lines
-      end
-
-      private
-
-      def read_bit(one)
-        if @byte_ready
-          @byte_ready = false
-          byte_ready_ended!
-        end
-        @shift = ((@shift << 1) & 0x3fe) | (one ? 1 : 0)
-        if one
-          @ones += 1
-          @sync = true if @ones >= SYNC_BITS
-        else
-          @ones = 0
-          @sync = false
-        end
-        count_bit
-      end
-
-      # The write shift register's top bit goes onto the track through the
-      # write gate, and into the read shift register, as the head's own
-      # signal.
-      def write_bit(at)
-        if @byte_ready
-          @byte_ready = false
-          byte_ready_ended!
-        end
-        one = @write_shift.anybits?(0x80)
-        @write_shift = (@write_shift << 1) & 0xff
-        store_bit(one, at) if @write_gate
-        @shift = ((@shift << 1) & 0x3fe) | (one ? 1 : 0)
-        @ones = one ? @ones + 1 : 0
-        count_bit
-      end
-
-      # Each bit written goes in the cell after the last one's, from the
-      # cell under the head when the write started.
-      def store_bit(one, at)
-        track_written(at) unless @track_written
-        @write_index ||= (@index * 8) + 8 - @mask.bit_length
-        index = @write_index >> 3
-        mask = 0x80 >> (@write_index & 7)
-        if one
-          @bytes[index] |= mask
-        else
-          @bytes[index] &= ~mask
-        end
-        @write_index += 1
-        @write_index = 0 if @write_index == @length * 8
-      end
-
-      # The first write to the track since the head came to it or the rate
-      # changed: a half track without data gets a blank track, and a track
-      # written at another rate is laid out again at this one.
-      def track_written(at)
-        surface = self.surface
-        track = @disk.writable_track(surface, @zone)
-        @disk.write(surface, track.relaid(@zone)) unless track.written_at?(@zone)
-        load_track(at)
-        @disk.written(surface)
-        @track_written = true
-      end
-
-      # Every eighth bit outside a SYNC mark is BYTE READY, which loads the
-      # write shift register: from what the VIA drives on port A in write
-      # mode, and with the byte just read otherwise.
-      def count_bit
-        if @sync
-          @bits = 0
-          return
-        end
-        @bits += 1
-        return unless @bits == 8
-
-        @bits = 0
-        @write_shift = @writing ? @via.port_a_output : @shift & 0xff
-        @byte_ready = true
-        byte_ready!
-      end
-
-      # The stepper's rotor turns with the head, a phase to each half
-      # track, so the energized phase pulls the head to the neighbouring
-      # half track it belongs to. A phase two away pulls both ways, and the
-      # head stays. Against the stop at track 1 the head can't follow, and
-      # the phases slip round to where the head is.
-      def step(phase)
-        move = (phase - @half_track - @slip) & 0x03
-        if move == 1
-          seek(@half_track + 1)
-        elsif move == 3 && @half_track == MIN_HALF_TRACK
-          @slip = (phase - MIN_HALF_TRACK) & 0x03
-        elsif move == 3
-          seek(@half_track - 1)
-        end
-      end
-
-      # The half track under the head that reads, numbered on the disk
-      # (see Disk::SIDE).
-      def surface = @half_track + @side_base
-
-      def seek(half_track)
-        half_track = half_track.clamp(MIN_HALF_TRACK, Disk::MAX_HALF_TRACK)
-        return if half_track == @half_track
-
-        @half_track = half_track
-        load_track
-      end
-    end
-  end
-end

data/lib/badline/drive1541/mechanism_state.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Drive1541
-    # Saving and restoring the Mechanism for a snapshot.
-    module MechanismState
-      # The disk (Disk#save_state) and everything the head, the motor, the
-      # stepper and the read and write electronics hold, down to the cell
-      # under the head and the read clock's phase.
-      def save_state(out)
-        out.boolean(!@disk.nil?)
-        @disk&.save_state(out)
-        [@half_track, @slip, @side_base, @zone, @clock, @time, @clock_at, @clocks, @shift, @ones, @bits, @write_shift,
-         @index, @mask, @cell_end, @width, @next].each { |value| out.int(value) }
-        [@motor, @led, @sync, @byte_ready, @byte_latched, @writing, @write_gate, @protected,
-         @track_written].each { |flag| out.boolean(flag) }
-        out.optional_int(@write_index)
-      end
-
-      # Puts the state back, reusing the disk in when it's the one the state
-      # names (Disk::State.load). A disk taken out is flushed, as insert
-      # does.
-      def load_state(input)
-        disk = input.boolean? ? Disk::State.load(input, @disk) : nil
-        flush unless disk.equal?(@disk)
-        @disk = disk
-        load_head(input)
-        load_flags(input)
-        @write_index = input.optional_int
-        head_on_track
-      end
-
-      private
-
-      def load_head(input)
-        @half_track = input.int
-        @slip = input.int
-        @side_base = input.int
-        @zone = input.int
-        @clock = input.int
-        @time = input.int
-        @clock_at = input.int
-        @clocks = input.int
-        @shift = input.int
-        @ones = input.int
-        @bits = input.int
-        @write_shift = input.int
-        @index = input.int
-        @mask = input.int
-        @cell_end = input.int
-        @width = input.int
-        @next = input.int
-      end
-
-      def load_flags(input)
-        @motor = input.boolean?
-        @led = input.boolean?
-        @sync = input.boolean?
-        @byte_ready = input.boolean?
-        @byte_latched = input.boolean?
-        @writing = input.boolean?
-        @write_gate = input.boolean?
-        @protected = input.boolean?
-        @track_written = input.boolean?
-      end
-    end
-  end
-end

data/lib/badline/drive1541/rotation.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Drive1541
-    # The disk turning under the Mechanism's head, and its read clock.
-    #
-    # The disk turns at 300 rpm, whatever the bit rate: once in 200 ms, or
-    # 200,000 drive cycles. Each track's bits pass under the head at the
-    # rate they were written at (see Track), and a 1 bit is a flux
-    # transition at the start of its cell.
-    #
-    # The read circuit clocks bits out at the rate PB5-6 select, from a
-    # counter the 16 MHz crystal steps every 16 - zone ticks. A flux
-    # transition clears the counter. The counter clocks a bit into the
-    # read shift register as it reaches 2 and every four steps after
-    # that, and the bit is a 1 only for the first clock after the counter
-    # passed 0. A bit is 4 * (16 - zone) ticks, so a byte takes 32, 30, 28
-    # or 26 drive cycles in zones 0 to 3, and each transition brings the
-    # clock back into step with the flux. A track read at the rate it was
-    # written reads its bits. At another rate the clock and the cells
-    # drift apart between transitions: a faster clock slips an extra 0
-    # bit into some runs of 0 bits, a slower one drops one from some, and
-    # the bytes come out garbled. Without flux the counter runs round on
-    # its own and reads a 1 bit in every four.
-    module Rotation
-      CYCLE = 16 * Track::TICK
-
-      # What the head reads with no disk in, or off the tracks a disk has:
-      # no flux.
-      BLANK = Track.new(Array.new(Disk::TRACK_LENGTHS[0], 0).freeze, 0)
-
-      # One drive cycle: nothing with the motor off, and otherwise the
-      # disk turns on by a cycle's ticks, 16 at 1 MHz and 8 at 2 MHz,
-      # through whatever cells and clocks fall in them.
-      def cycle!
-        return unless @motor
-
-        @time += @cycle_ticks
-        pass_time if @time >= @next
-      end
-
-      private
-
-      # The cell edges and clocks up to now, in the order they come. A
-      # clock that falls on a cell edge comes after it.
-      def pass_time
-        while @cell_end <= @time || @clock_at <= @time
-          if @cell_end <= @clock_at
-            next_cell
-          else
-            clock
-          end
-        end
-        @next = [@cell_end, @clock_at].min
-      end
-
-      # The head comes to the next cell, and a 1 bit's flux clears the
-      # read clock while reading.
-      def next_cell
-        start = @cell_end
-        @mask >>= 1
-        start = next_byte(start) if @mask.zero?
-        @cell_end = @index == @last && @mask == 1 ? Track::TURN : start + @width
-        return if @writing || @bytes[@index].nobits?(@mask)
-
-        @clock_at = start + (@clock / 2)
-        @clocks = 0
-      end
-
-      # The head comes to the next byte, and at the end of the track back
-      # round to the first, where the turn starts over.
-      def next_byte(start)
-        @mask = 0x80
-        @index += 1
-        if @index == @length
-          @index = 0
-          @time -= Track::TURN
-          @clock_at -= Track::TURN
-          start = 0
-        end
-        @width = @widths[@index] if @widths
-        start
-      end
-
-      # The read clock ticks a bit into the shift register: a 1 the first
-      # time after a flux transition or the counter's wrap.
-      def clock
-        at = @clock_at
-        one = @clocks.zero?
-        @clocks = (@clocks + 1) & 3
-        @clock_at = at + @clock
-        @writing ? write_bit(at) : read_bit(one)
-      end
-
-      # The track under the head and its layout, leaving the head's place
-      # on it as it stands.
-      def head_on_track
-        @track = @disk&.track(surface) || BLANK
-        @bytes = @track.bytes
-        @widths = @track.widths
-        @length = @track.length
-        @last = @length - 1
-      end
-
-      # The track under the head, from the cell that's under it +time+
-      # into the turn.
-      def load_track(time = @time)
-        @track = @disk&.track(surface) || BLANK
-        @bytes = @track.bytes
-        @widths = @track.widths
-        @length = @track.length
-        @last = @length - 1
-        @index, @mask, @cell_end = @track.cell_at(time)
-        @width = @widths ? @widths[@index] : @track.width
-        @write_index = nil
-        @track_written = false
-        @next = [@cell_end, @clock_at].min
-      end
-    end
-  end
-end